Dual-binary Turbo decoding method based on deep learning

Abstract

The invention provides a dual-binary Turbo decoding method based on deep learning, and belongs to the technical field of wireless communication. Comprising the following steps: generating a binary random bit stream as original information, and generating a Turbo code sequence through two recursive system convolutional code component encoders; pre-processing the Turbo code sequence, and inputting the pre-processed Turbo code sequence into a bidirectional PNN model for processing to obtain an output feature vector; based on the output feature vector, standardization is carried out through a batch normalization layer, and a decoding result probability value is output by using a full connection layer and a Sigmoid activation function; and on the basis of the decoding result probability value, a Max-Log-MAP algorithm is cascaded with a component decoder of the bidirectional RNN to obtain a decoding result.

Description

Technical Field

[0001] The present application belongs to the field of wireless communication technology, and specifically relates to a dual binary Turbo decoding method based on deep learning. Background Art

[0002] In the field of wireless communications, error correction coding technology has been widely used and developed to ensure reliable and efficient data transmission. Since its introduction in the 1990s, Turbo codes, as a highly efficient error correction coding method, have occupied a key position in modern communication systems due to their superior performance. Turbo codes generate redundant information through two recursive systematic convolutional code (RSC) component encoders and an interleaver, significantly improving data transmission reliability.

[0003] Traditional Turbo code decoding relies primarily on iterative decoding methods such as the Max-Log-MAP algorithm, which recover the original information through log-likelihood ratio (LLR) calculation, forward and backward probability estimation, and path selection. However, with the growth of communication needs and technological advancements, existing technologies face new challenges:

[0004] Traditional Max-Log-MAP algorithms require extensive computational resources, particularly when processing long sequences, where their complexity increases dramatically. In high-noise environments, traditional methods still exhibit high bit error rates (BERs), making them difficult to meet the demands of high-performance communications. Existing Turbo code decoding methods fail to fully leverage the powerful feature extraction capabilities of deep learning models, limiting the potential for further improvements in error correction performance.

[0005] The inventors have discovered that the above problems lead to the inability to efficiently and accurately decode Turbo codes in complex and changeable actual communication environments. The existing methods have high computational complexity and low robustness to noise. Summary of the Invention

[0006] In order to solve at least one technical problem in the background technology, the present application provides a deep learning-based dual binary Turbo decoding method.

[0007] The second embodiment of the present application provides a dual binary Turbo decoding system based on deep learning.

[0008] The technical solutions adopted in this application are:

[0009] The first embodiment of the present application provides a deep learning-based duobinary turbo decoding method, including:

[0010] Generate a binary random bit stream as the original information and generate a turbo code sequence through two recursive systematic convolutional code component encoders;

[0011] Preprocessing the Turbo code sequence and inputting it into a bidirectional PNN model for processing to obtain an output feature vector;

[0012] Based on the output feature vector, the batch normalization layer is used to perform normalization, and the fully connected layer and the Sigmoid activation function are used to output the probability value of the decoding result;

[0013] Based on the decoding result probability value, the Max-Log-MAP algorithm is cascaded with the component decoders of the bidirectional RNN to obtain the decoding result.

[0014] According to one embodiment of the present application, the generating of a binary random bit stream as original information and the generating of a Turbo code sequence by two recursive systematic convolutional code component encoders are specifically as follows:

[0015] Generate a binary random bit stream as the original information, with a frame length of N;

[0016] The original information passes through a first recursive systematic convolutional code encoder to output a forward coded sequence;

[0017] The original information is disrupted by an interleaver to generate a randomly arranged bit stream;

[0018] The interleaved information is passed through a second recursive systematic convolutional code encoder to output a backward coded sequence;

[0019] The original information, the forward coding sequence and the backward coding sequence are combined to form the Turbo code sequence.

[0020] According to one embodiment of the present application, the preprocessing of the Turbo code sequence and inputting it into the bidirectional PNN model for processing to obtain an output feature vector is specifically as follows:

[0021] Transmitting the Turbo code sequence through a noisy channel to output a noisy Turbo code sequence;

[0022] Split the noisy Turbo code sequence into forward code, backward code and original information;

[0023] Standardize or normalize the data and output the preprocessed noisy Turbo code sequence as the model input;

[0024] Input the preprocessed noisy Turbo code sequence in chronological order, process it moment by moment in the forward RNN, and output the forward hidden state;

[0025] Input the sequence in reverse time order, process it moment by moment in the backward RNN, and output the backward hidden state;

[0026] The forward hidden state and the backward hidden state are concatenated to form a feature vector that integrates the context information, and the output feature vector of the bidirectional RNN is output.

[0027] According to one embodiment of the present application, the output feature vector is standardized by a batch normalization layer, and a fully connected layer and a Sigmoid activation function are used to output a decoding result probability value, specifically:

[0028] performing mean and variance normalization on the output feature vector;

[0029] Calculate the linear combination through the fully connected layer and output the log-likelihood ratio of the decoding result;

[0030] The log-likelihood ratio is mapped to the interval [0, 1] using a Sigmoid function to output a decoding result probability value.

[0031] According to one embodiment of the present application, based on the decoding result probability value, the Max-Log-MAP algorithm is cascaded with the component decoder of the bidirectional RNN to obtain the decoding result, specifically:

[0032] The probability values ​​based on the first decoding result are rearranged through an interleaver and input into the second component decoder;

[0033] The two component decoders alternately update external information and optimize path selection using the Max-Log-MAP algorithm;

[0034] Calculate the forward probability and backward probability, and optimize the decoding path based on the log-likelihood ratio of the noisy channel;

[0035] Output the decoding results after multiple iterations of optimization.

[0036] According to one embodiment of the present application, after obtaining a decoding result by cascading a Max-Log-MAP algorithm and a component decoder of a bidirectional RNN based on the decoding result probability value, the method further includes:

[0037] Converting the decoding result into a binary bit stream through a threshold;

[0038] The result is compared with the original information to calculate the bit error rate.

[0039] A second aspect of the present application provides a deep learning-based duobinary turbo decoding system according to any one of the first aspects, including:

[0040] An encoding module, configured to generate a binary random bit stream as original information and generate a turbo code sequence through two recursive systematic convolutional code component encoders;

[0041] A preprocessing module, configured to preprocess the Turbo code sequence and input the preprocessed data into a bidirectional PNN model for processing to obtain an output feature vector;

[0042] A decoding module is configured to perform normalization based on the output feature vector through a batch normalization layer, and output a decoding result probability value using a fully connected layer and a Sigmoid activation function;

[0043] The iterative optimization module is used to obtain a decoding result based on the decoding result probability value by using the Max-Log-MAP algorithm and the component decoder cascade of the bidirectional RNN.

[0044] According to one embodiment of the present application, the encoding module is specifically:

[0045] Generate a binary random bit stream as the original information, with a frame length of N;

[0046] The original information passes through a first recursive systematic convolutional code encoder to output a forward coded sequence;

[0047] The original information is disrupted by an interleaver to generate a randomly arranged bit stream;

[0048] The interleaved information is passed through a second recursive systematic convolutional code encoder to output a backward coded sequence;

[0049] The original information, the forward coding sequence and the backward coding sequence are combined to form the Turbo code sequence.

[0050] According to one embodiment of the present application, the preprocessing module is specifically:

[0051] Transmitting the Turbo code sequence through a noisy channel to output a noisy Turbo code sequence;

[0052] Split the noisy Turbo code sequence into forward code, backward code and original information;

[0053] Standardize or normalize the data and output the preprocessed noisy Turbo code sequence as the model input;

[0054] Input the preprocessed noisy Turbo code sequence in chronological order, process it moment by moment in the forward RNN, and output the forward hidden state;

[0055] Input the sequence in reverse time order, process it moment by moment in the backward RNN, and output the backward hidden state;

[0056] The forward hidden state and the backward hidden state are concatenated to form a feature vector that integrates the context information, and the output feature vector of the bidirectional RNN is output.

[0057] An embodiment of a third aspect of the present application provides an electronic device, including a memory, a processor, and a computer program stored on the memory and executable on the processor. When the processor executes the program, a deep learning-based dual binary Turbo decoding method as described in any embodiment of the second aspect is implemented.

[0058] Due to the adoption of the above technical solution, the beneficial effects achieved by this application are as follows:

[0059] This application uses two RSC encoders and an interleaver to increase redundancy, enabling effective error correction even in high-noise environments. Coding parameters such as frame length and interleaving method can be adjusted according to specific application requirements to optimize the overall performance of the system.

[0060] This application enhances the system's adaptability to various types of noise by simulating actual channel conditions, adding noise, and using a bidirectional PNN model to process noisy Turbo code sequences. The bidirectional PNN model can capture the temporal dependencies of sequences, providing richer contextual information that aids in the subsequent decoding process.

[0061] The batch normalization layer in this application ensures the consistency and stability of the input data, accelerates the training process, and improves the generalization ability of the model. The fully connected layer combined with the Sigmoid activation function provides a probability value for each bit to be 0 or 1, providing a reliable basis for subsequent hard and soft decisions.

[0062] This application's Max-Log-MAP algorithm, combined with a bidirectional RNN component decoder cascade, gradually approaches the optimal solution through multiple iterations, significantly improving decoding accuracy. Compared to using the Max-Log-MAP algorithm alone, this approach, combined with a deep learning model, can maintain high accuracy while reducing the computational burden, making it suitable for real-time communication scenarios. BRIEF DESCRIPTION OF THE DRAWINGS

[0063] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0064] Figure 1 A flowchart of a deep learning-based duobinary Turbo decoding method provided in an embodiment of the present application;

[0065] Figure 2 A schematic diagram of the structure of an electronic device provided in an embodiment of the present application;

[0066] Figure 3A diagram of a duo-binary Turbo decoding architecture for a deep learning-based duo-binary Turbo decoding method provided in an embodiment of the present application;

[0067] Figure 4 This is a diagram of the RNN decoding unit architecture of a deep learning-based duobinary Turbo decoding method provided in an embodiment of the present application;

[0068] Figure 5 A bidirectional RNN decoding unit architecture diagram of a deep learning-based dual binary turbo decoding method provided in an embodiment of the present application;

[0069] Figure 6 A bidirectional RNN network training structure of a deep learning-based dual binary Turbo decoding method is provided in an embodiment of the present application.

[0070] Reference numerals:

[0071] 810 , processor; 820 , communication interface; 830 , memory; 840 , communication bus. DETAILED DESCRIPTION

[0072] In order to more clearly illustrate the overall concept of the present application, a detailed description is given below in an illustrative manner in conjunction with the accompanying drawings.

[0073] The following description sets forth many specific details to facilitate a thorough understanding of the present application. However, the present application may also be implemented in other ways than those described herein, and therefore, the scope of protection of the present application is not limited by the specific embodiments disclosed below. It should be noted that the embodiments of the present application and the features of each embodiment may be combined with each other unless there is a conflict.

[0074] In this application, unless otherwise expressly specified and limited, a first feature "above" or "below" a second feature may be that the first and second features are in direct contact, or the first and second features are in indirect contact through an intermediate medium. In the description of this specification, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example", or "some examples" means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present application. In this specification, the schematic representation of the above terms does not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials or characteristics described may be combined in an appropriate manner in any one or more embodiments or examples.

[0075] like Figure 1 As shown, the first embodiment of the present application provides a deep learning-based duobinary turbo decoding method, including:

[0076] S100 , generating a binary random bit stream as original information, and generating a Turbo code sequence through two recursive systematic convolutional code component encoders.

[0077] As mentioned above, in a communication system, the information to be transmitted is first converted into binary form. In order to test and verify the effectiveness of turbo coding, a random binary bit stream is usually generated as the original information.

[0078] The system generates a random sequence of 0s and 1s, the length of which is determined by actual requirements (for example, a frame length of N bits). This sequence represents the data to be transmitted, which can be any form of information (such as text or images) that has been digitized. These bit streams are completely random, simulating various data patterns in real-world applications. For example, if an 8-bit random bit stream is generated, it might be 10110010.

[0079] The core of turbo codes is to encode the original information using two recursive systematic convolutional code (RSC) component encoders. Each RSC encoder generates a redundant version of the input data, so that even if errors occur during transmission, the receiver can use this redundant information to recover the original data.

[0080] The first component encoder input generates a raw binary random bit stream. The RSC encoder is a special convolutional encoder characterized by a feedback path, meaning that the output at a given moment depends not only on the current input but also on the previous state. For each input bit, the encoder generates one or more output bits. For example, given the input bit stream 10110010, the encoder calculates the corresponding output bit stream based on its internal state and a specific algorithm. The output bit stream contains additional redundant information, which helps correct possible transmission errors at the receiving end.

[0081] Before being processed by the second component encoder, the original bit stream passes through an interleaver. The interleaver's function is to disrupt the order of the bit stream, distributing any consecutive errors that may occur during transmission and thus improving error correction. The original bit stream is shuffled according to predefined rules. For example, the original bit stream 10110010 might become 11001010 after interleaving. This reordering ensures that even if consecutive errors occur during transmission, they are not concentrated in the same segment of data but are instead distributed, allowing for more efficient correction during subsequent decoding.

[0082] The second component encoder takes as input the interleaved bit stream. Similar to the first component encoder, it also uses RSC encoding. However, because it uses an interleaved bit stream as input, the resulting output bit stream differs from the output of the first component encoder. This encoder also generates corresponding output bits for each input bit, and these output bits also contain redundant information to aid in recovering the original data.

[0083] Turbo codes are composed of three components: the original information, the output of the first component encoder, and the output of the second component encoder. In practical applications, only the encoded data (i.e., the outputs of the two component encoders) is typically transmitted, while the receiver attempts to recover the original information through a deinterleaver and two component decoders. This design gives Turbo codes powerful error correction capabilities, especially in high-noise environments.

[0084] Through the above steps, the system can convert any binary random bit stream into a more reliable and anti-interference Turbo code sequence, greatly improving the quality and reliability of data transmission.

[0085] For example, the original information is 10110010, and this 8-bit binary string is the data to be transmitted.

[0086] Next, this original information is input into the first recursive systematic convolutional code (RSC) component encoder for encoding.

[0087] Assume that the RSC encoder used adopts a (2,1,2) structure, which means that each input bit generates two output bits, and there are two register states inside the encoder to store historical information. The encoding process is as follows:

[0088] Assume that the two register states of the encoder are initialized to 00.

[0089] For an input bit of 1, the encoder computes an output vector (1, 1). Here, the first output bit is directly equal to the input bit 1, and the second output bit is the XOR result of the input bit and the first component of the register state (i.e., 1XOR 0 = 1).

[0090] The register state is updated to (1, 0), where the new first component is the XOR result of the second component of the register state at the previous moment and the current input bit (i.e., 0XOR 1=1), and the new second component directly inherits the first component at the previous moment.

[0091] Continue to repeat the above process for the remaining bits 0110010.

[0092] Finally, the first RSC encoder might generate the following output sequence:

[0093] First component encoder output: 11 00 11 10 00 10 10 01

[0094] Before the original information is fed into the second RSC encoder, it needs to be interleaved. The interleaver disrupts the order of bits to disperse potential consecutive errors.

[0095] Assume that a simple interleaving rule is used, such as swapping every other bit (the actual application may be more complicated). For the original information 10110010, after interleaving, it becomes:

[0096] Interleaved information: 11001010

[0097] Now, the interleaved information is input into the second RSC component encoder for encoding.

[0098] Like the first encoder, the second RSC encoder also uses a (2,1,2) structure and follows the same encoding logic. Since the input is interleaved information, the output sequence will be different.

[0099] Initial state: Also initialized to 00.

[0100] Coding steps:

[0101] For an input bit of 1, the encoder computes the output vector (1,1).

[0102] Update the register status to (1,0).

[0103] Continue to repeat the above process for the remaining bits 1001010.

[0104] Finally, the second RSC encoder might generate the following output sequence:

[0105] Second component encoder output: 11 10 00 11 01 10 10 00

[0106] Finally, the outputs of the first component encoder and the second component encoder are combined to form the complete Turbo code sequence. Usually, the original information is not sent directly, but only the outputs of the two encoders are sent.

[0107] It consists of the first component encoder output 11 00 11 10 00 10 10 01 and the second component encoder output 11 1000 11 01 10 10 00.

[0108] In this way, a complete Turbo code sequence is obtained and is ready for transmission through the channel. At the receiving end, the original information can be restored through the corresponding decoding algorithm (such as the Max-Log-MAP algorithm combined with the bidirectional RNN model).

[0109] It should be noted that in specific implementation scenarios, in addition to using bidirectional RNNs (BRNNs), other deep learning models, such as long short-term memory (LSTM) or gated recurrent units (GRUs), can be explored based on the above solution. These models may be more effective in processing long-term dependencies. By combining the advantages of deep learning models, the Max-Log-MAP algorithm can be improved, for example, by using adaptive threshold adjustment and dynamic branch metric calculation to improve decoding speed and accuracy.

[0110] In specific implementation scenarios, in addition to Gaussian white noise, the above scheme can also be used to simulate other types of channel noise, such as Rayleigh fading channels and Ricean channels, and train the model to adapt to these complex channel conditions. A real-time channel estimation module can be developed to dynamically adjust encoding and decoding parameters based on channel state information (CSI), enabling the system to maintain optimal performance under different channel conditions.

[0111] S200 , preprocessing the Turbo code sequence and inputting it into a bidirectional PNN model for processing to obtain an output feature vector.

[0112] As mentioned above, first, a turbo code sequence is generated by two recursive systematic convolutional code (RSC) component encoders and an interleaver. This process has been explained in detail in the previous discussion.

[0113] For example, suppose there is an original information 10110010, which is encoded to obtain a Turbo code sequence.

[0114] To simulate various interference conditions that may be encountered in actual communication environments, it is necessary to add different types of noise to the generated Turbo code sequence. This can help train a decoding model that is more adaptable to real-world conditions.

[0115] White Gaussian Noise (AWGN): The most common type of noise, used to simulate the natural attenuation and random fluctuations of signals in wireless channels.

[0116] Burst noise: used to simulate strong interference in a short period of time, such as thunderstorms or electromagnetic pulses.

[0117] In experiments, different signal-to-noise ratios (SNRs), which are the ratio of signal power to noise power, are usually set to control the intensity of the noise. For example, in the case of an SNR of 0 dB, the energy of the signal is equal to the energy of the noise.

[0118] For each Turbo code bit, the corresponding noise level is calculated based on the set SNR value and superimposed on the original Turbo code sequence, thus obtaining a noisy Turbo code sequence.

[0119] In order for neural networks to learn more effectively, it is usually necessary to normalize the input data. This helps speed up the training process and improve the stability of the model.

[0120] Map the noisy Turbo code sequence to a specific interval (such as [0,1] or [-1,1]). This can be achieved through a simple linear transformation. For example, for a binary sequence {0,1}, it can be converted to {-1,1}, or normalized to the range [0,1].

[0121] This step ensures the consistency and comparability of the input data, and prevents certain features from affecting the learning effect of the model due to excessively large or small values.

[0122] The powerful ability of the bidirectional RNN model is used to capture the temporal dependency of the Turbo code sequence, thereby extracting useful feature vectors.

[0123] The normalized noisy Turbo code sequence is fed into the bidirectional RNN model in both forward and reverse order. This allows the model to not only consider the current moment but also combine the previous and next contextual information to make more accurate predictions.

[0124] At each time step, the bidirectional RNN updates its internal state, storing information about the current moment, the previous moment, and the next moment. These states are passed to the next layer until the entire sequence is processed.

[0125] After a series of hidden layer calculations, the bidirectional RNN outputs a feature vector that contains all the relevant information of the sequence and has been optimized for use in subsequent steps.

[0126] For example, suppose the information to be sent is a simple 8-bit binary random bit stream:

[0127] Original message: 10110010

[0128] The Turbo code sequence is generated by two recursive systematic convolutional code (RSC) component encoders and interleavers. Here, we simplify the example and assume that the Turbo code sequence obtained after encoding is:

[0129] Turbo code sequence:

[0130] Original message: 10110010

[0131] First component encoder output: 11 00 11 10 00 10 10 01

[0132] Second component encoder output: 11 10 00 11 01 10 10 00

[0133] In practical applications, usually only the outputs of the two component encoders are sent.

[0134] To simulate interference in a real communication environment, it is necessary to add noise to the generated Turbo code sequence. Here, we will use Gaussian white noise (AWGN) as an example.

[0135] Signal-to-noise ratio (SNR) setting: Setting it to 0dB means that the energy of the signal is equal to the energy of the noise.

[0136] For each Turbo code bit, the corresponding noise level is calculated according to the set SNR value and superimposed on the original Turbo code sequence.

[0137] Assume that the turbo code sequence output by the first component encoder is 11 00 11 10 00 10 10 01. After adding noise, the result may be floating-point values ​​such as 1.1, -0.1, -0.2, 0.9, 0.1, 1.05, 0.95, -0.05 (the specific value depends on the specific implementation method of the noise).

[0138] Similarly, the Turbo code sequence 11 10 00 11 01 10 10 00 output by the second component encoder may become 1.05, 0.95, -0.1, 1.05, 0.95, 1.05, 0.95, -0.05 after noise processing.

[0139] In order to enable neural networks to learn more effectively, the noisy Turbo code sequence needs to be normalized. This step ensures the consistency and comparability of the data.

[0140] Map the noisy turbo code sequence to a specific interval (such as [-1,1] or [0,1]). For example, we can choose to scale all values ​​to the interval [-1,1].

[0141] For the noisy sequence 1.1, -0.1, -0.2, 0.9, 0.1, 1.05, 0.95, -0.05 output by the first component encoder, it may become 0.9, -0.6, -0.7, 0.4, -0.6, 0.95, 0.45, -0.6 after normalization.

[0142] For the noisy sequence 1.05, 0.95, -0.1, 1.05, 0.95, 1.05, 0.95, -0.05 output by the second component encoder, it may become 0.95, 0.45, -0.6, 0.95, 0.45, 0.95, 0.45, -0.6 after normalization.

[0143] Now that the normalized noisy Turbo code sequence has been obtained, it is input into the bidirectional RNN model for processing.

[0144] The normalized noisy Turbo code sequence is input into the bidirectional RNN model in both forward and reverse order.

[0145] Positive sequence input: 0.9, -0.6, -0.7, 0.4, -0.6, 0.95, 0.45, -0.6 (first component)

[0146] Input in reverse order: -0.6, 0.45, 0.95, -0.6, 0.4, -0.7, -0.6, 0.9 (first component)

[0147] The same steps are applied to the output of the second component encoder.

[0148] At each time step, the bidirectional RNN updates its internal state, storing information about the current, previous, and next time steps. These states are passed to the next layer until the entire sequence is processed. For example, during the first time step, the forward RNN receives 0.9 and the reverse RNN receives -0.6, and updates their hidden layer states accordingly. As the sequence progresses, more contextual information is incorporated into the hidden layer states.

[0149] After a series of hidden layer calculations, the bidirectional RNN outputs a feature vector that contains all the relevant information of the sequence and has been optimized for use in subsequent steps.

[0150] Assume that after the bidirectional RNN processes the above sequence, the output feature vector is as follows:

[0151] [-0.3,0.2,0.1,-0.4,0.3,-0.1,0.2,-0.3] (first component)

[0152] [0.2,-0.1,0.3,-0.4,0.1,0.2,-0.3,0.3] (second component)

[0153] These feature vectors contain rich contextual information, which helps in subsequent hard decision and decoding decisions.

[0154] It should be noted that in specific implementation scenarios, in addition to white Gaussian noise (AWGN), other types of channel noise, such as Rayleigh fading and Rician fading, can be simulated based on the above scheme. This approach allows the trained model to better cope with the complex channel conditions found in various practical application scenarios. An adaptive noise adjustment mechanism is introduced to dynamically adjust the noise level at different iteration stages or based on the current model's performance, thereby improving the model's robustness and generalization capabilities in various noise environments.

[0155] In specific implementation scenarios, data augmentation techniques can be used to enrich the training set based on the above solutions. For example, by randomly perturbing, flipping, and scaling the original data, more training samples can be generated to increase the learning diversity of the model. Exploring more advanced data normalization methods, such as Z-score normalization and Min-Max normalization, can ensure a more reasonable distribution of input data and help improve model performance.

[0156] In specific implementation scenarios, in addition to using bidirectional RNNs, you can also try long short-term memory (LSTM), gated recurrent units (GRU), or Transformer architectures based on the above solutions. These models may perform better when processing long sequence dependencies. Combining the advantages of convolutional neural networks (CNNs) and RNNs to build hybrid models, using CNNs to extract local features and RNNs to capture global temporal dependencies, can improve overall model performance.

[0157] In specific implementation scenarios, a real-time channel estimation module can be developed based on the above solution to dynamically adjust encoding and decoding parameters based on channel state information, enabling the system to maintain optimal performance under varying channel conditions. Based on the current channel conditions, the most appropriate modulation scheme, such as BPSK or QPSK, can be intelligently selected to maximize transmission efficiency and reliability.

[0158] S300 , based on the output feature vector, normalize it through a batch normalization layer, and use a fully connected layer and a Sigmoid activation function to output a decoding result probability value.

[0159] As mentioned above, the main purpose of the batch normalization layer is to standardize the feature vectors so that the input distribution of each layer is more stable and consistent, thereby accelerating the training process and improving the stability of the model.

[0160] In this layer, the model calculates the mean and variance of all samples in the current batch and uses these statistics to standardize each element in the feature vector.

[0161] This normalization ensures that the data distribution between different batches does not differ too much, which helps prevent the gradient from disappearing or exploding, and also reduces the risk of overfitting.

[0162] The feature vector after batch normalization has a more uniform distribution and is usually adjusted to be close to the standard normal distribution (mean 0, variance 1), which is conducive to the learning and optimization of subsequent layers.

[0163] The fully connected layer is used to further extract features and map high-dimensional features to a low-dimensional space in order to make the final decision. In this step, it converts the batch normalized feature vector into a form suitable for the final classification task.

[0164] Each neuron is connected to all neurons in the previous layer, forming a densely connected network.

[0165] In this layer, the model performs a linear transformation on the input feature vector (i.e., weighted summation plus a bias term) and passes the result to the next layer or directly as output.

[0166] This step can be regarded as "compressing" or "decompressing" the feature vector to make it more suitable for subsequent classification tasks.

[0167] The Sigmoid activation function is used to map the output of the fully connected layer to the interval [0,1], representing the probability of each bit being 0 or 1.

[0168] The Sigmoid function is a common nonlinear activation function whose output range is between 0 and 1, which is very suitable for binary classification tasks.

[0169] For each output node, the sigmoid function converts its input value to a number between 0 and 1, which can be interpreted as the probability that the bit is 1 (or equivalently, the probability of being 0 is its complement, that is, 1 minus the value).

[0170] For example, if the Sigmoid output value corresponding to a certain bit is 0.85, it means that the model believes that the probability of the bit being 1 is 85%, and vice versa, the probability is 15%.

[0171] The ultimate goal is to determine the actual value (0 or 1) of each bit from the output of the Sigmoid activation function, that is, to complete the recovery from the noisy signal to the original information.

[0172] The model determines the final state of each bit based on the output value of the Sigmoid function. Typically, if the output value is greater than a threshold (such as 0.5), the bit is considered to be 1; otherwise, it is considered to be 0.

[0173] These probability values ​​provide not only the hard decision of the bit, but also the soft decision, that is, the confidence that each bit is 0 or 1.

[0174] Soft decision information is very important for the subsequent iterative decoding process because it can help the system gradually approach the optimal solution after multiple iterations.

[0175] Through the above steps, the output feature vector generated by the bidirectional RNN model is normalized by the batch normalization layer, then extracted and transformed by the fully connected layer. Finally, the sigmoid activation function is used to output the probability value of each bit being 0 or 1. This series of operations not only improves the stability and generalization ability of the model but also provides a reliable foundation for subsequent hard and soft decisions, thereby achieving efficient Turbo code decoding.

[0176] For example, suppose the output feature vector after processing by the bidirectional RNN model is as follows (simplified example):

[0177] Output feature vector: [2.5, -1.3, 0.8, -0.6, 1.4, 0.9, -1.1, 0.7]

[0178] This feature vector contains the time dependency information and context information of the input Turbo code sequence.

[0179] The role of the batch normalization layer is to standardize each element in the feature vector to make its distribution more uniform and stable.

[0180] Assume that the mean of all samples in the current batch is 0.5 and the variance is 1.2.

[0181] Normalize each element using the formula (x-mean) / sqrt(variance), where x is the original eigenvalue, mean is the mean, and variance is the variance.

[0182] For example, for the first element 2.5, the normalized value is (2.5-0.5) / sqrt(1.2)≈1.83.

[0183] Similarly, normalize the other elements:

[0184] -1.3 after standardization is (-1.3-0.5) / sqrt(1.2)≈-1.58

[0185] After standardization, 0.8 is (0.8-0.5) / sqrt(1.2)≈0.27

[0186] -0.6 after standardization is (-0.6-0.5) / sqrt(1.2)≈-0.98

[0187] After standardization, 1.4 is (1.4-0.5) / sqrt(1.2)≈0.81

[0188] After 0.9 is standardized, it becomes (0.9-0.5) / sqrt(1.2)≈0.36

[0189] -1.1 after normalization is (-1.1-0.5) / sqrt(1.2)≈-1.45

[0190] After standardization, 0.7 is (0.7-0.5) / sqrt(1.2)≈0.18

[0191] Normalized eigenvector: [1.83, -1.58, 0.27, -0.98, 0.81, 0.36, -1.45, 0.18]

[0192] The fully connected layers are used to further extract features and map them into a form suitable for classification tasks.

[0193] Assume that the weight matrix of the fully connected layer is [0.5, -0.2, 0.3, 0.4, -0.1, 0.6, -0.3, 0.2] and the bias term is 0.1.

[0194] Perform weighted summation on the normalized eigenvectors and add a bias term:

[0195] 1.83*0.5+(-1.58)*(-0.2)+0.27*0.3+(-0.98)*0.4+0.81*(-0.1)+0.36*0.6+(-1.45)*(-0.3)+0.18*0.2+0.1

[0196] The calculation result is 1.115+0.316+0.081-0.392-0.081+0.216+0.435+0.036+0.1=1.826

[0197] Fully connected layer output: 1.826

[0198] The Sigmoid activation function is used to map the output of the fully connected layer to the interval [0,1], indicating the probability of each bit being 0 or 1.

[0199] The shape of the Sigmoid function is such that any input value can be compressed into the range (0,1).

[0200] Assume that the output formula of the Sigmoid function is 1 / (1+exp(-x)).

[0201] For the output of the fully connected layer, 1.826, the Sigmoid function is applied:

[0202] 1 / (1+exp(-1.826))≈0.86

[0203] Probability value after Sigmoid activation: 0.86

[0204] If the probability value is greater than a certain threshold (such as 0.5), the bit is determined to be 1; otherwise, it is determined to be 0.

[0205] In this example, the probability value is 0.86, which is greater than 0.5, so the bit is determined to be 1.

[0206] A probability value of 0.86 means that the model believes that there is an 86% probability that the bit is 1, and a 14% probability that it is 0.

[0207] This soft decision information can be used in subsequent iterative decoding processes to help the system gradually approach the optimal solution.

[0208] It should be noted that in specific implementation scenarios, based on the above solution, the parameters of batch normalization (such as mean and variance) can be dynamically adjusted according to the specific conditions of each batch to better adapt to different input distributions. In some cases, using layer normalization instead of batch normalization may bring better results, especially in the case of small batch sizes.

[0209] S400 , based on the decoding result probability value, utilize the Max-Log-MAP algorithm and the component decoder of the bidirectional RNN in cascade to obtain a decoding result.

[0210] As mentioned above, in the previous step, the noisy Turbo code sequence has been processed by the bidirectional RNN model, and the probability value of each bit being 0 or 1 has been obtained. These probability values ​​represent the model's confidence in the state of each bit. For example:

[0211] The probability value of bit A is 0.85, which means that the model believes that the probability of this bit being 1 is 85%, and conversely, there is a 15% probability that it is 0.

[0212] Similarly, other bits will also have a corresponding probability value.

[0213] The Max-Log-MAP algorithm is a traditional method for decoding turbo codes. It calculates the most likely bit sequence (i.e., hard decision) while providing soft information (i.e., probability) about the correctness of each bit. This algorithm evaluates all possible paths by calculating forward recursion, backward recursion, and branch metrics, and selects the optimal path as the final output.

[0214] To further improve decoding performance, the probability values ​​generated by the bidirectional RNN can be combined with the Max-Log-MAP algorithm. Specifically, the bidirectional RNN provides a preliminary probability estimate, while the Max-Log-MAP algorithm uses this to perform more accurate path search and error correction.

[0215] Turbo codes typically consist of two component encoders, necessitating two corresponding component decoders for decoding. These two component decoders are interconnected via an interleaver and deinterleaver, forming an iterative feedback loop. During each iteration, the two component decoders alternately update external information, gradually approaching the optimal solution.

[0216] First, the first component decoder (usually based on the Max-Log-MAP algorithm) is used to process the input data and generate the initial external information.

[0217] These external information contain soft information about the correctness of each bit (ie, probability value).

[0218] The extrinsic information generated by the first component decoder is shuffled through an interleaver and then passed to the second component decoder.

[0219] This step ensures that even if there are continuous errors in the original data, these errors will be dispersed after interleaving, making them easier to correct later.

[0220] The second component decoder receives the interleaved extrinsic information and again applies the Max-Log-MAP algorithm for processing.

[0221] After processing is completed, new extrinsic information is generated and reverse-interleaved back to the original order.

[0222] The entire process is repeated over multiple iterations, with each iteration updating the external information until a predetermined number of iterations is reached or certain convergence conditions are met. Each iteration aims to gradually reduce the bit error rate (BER) and improve decoding accuracy.

[0223] In the above process, the probability value provided by the bidirectional RNN is used as initial external information or as additional reference information to guide the selection process of the Max-Log-MAP algorithm. Specifically:

[0224] When the Max-Log-MAP algorithm performs forward recursion, backward recursion, and branch metric calculations, the probability values ​​generated by the bidirectional RNN can serve as a kind of "prior knowledge" to help the algorithm better identify the most likely path.

[0225] By leveraging the high-quality probability estimates provided by bidirectional RNNs, we can approach the optimal solution faster in early iterations, thereby reducing the number of required iterations and improving overall decoding efficiency.

[0226] After several iterations, the system generates a final hard decision based on the results of the last iteration, which is the specific value of each bit (0 or 1). These hard decisions constitute the final decoding result, which should theoretically be as close as possible to the original information sent.

[0227] In addition, soft information can be extracted from the final iteration results for further analysis or as feedback information to improve future transmissions.

[0228] By combining the probability values ​​generated by a bidirectional RNN with the traditional Max-Log-MAP algorithm and performing iterative optimization using a cascaded component decoder approach, we can effectively reduce computational complexity while maintaining high decoding accuracy. This approach not only improves the error correction capability of Turbo codes but also enhances the system's ability to withstand complex channel conditions, making it suitable for a variety of wireless communication scenarios.

[0229] For example, suppose the probability values ​​output by the bidirectional RNN model are as follows:

[0230] Bit 1: P(1) = 0.75, P(0) = 0.25

[0231] Bit 2: P(1) = 0.30, P(0) = 0.70

[0232] Bit 3: P(1) = 0.80, P(0) = 0.20

[0233] Bit 4: P(1) = 0.60, P(0) = 0.40

[0234] Bit 5: P(1) = 0.20, P(0) = 0.80

[0235] Bit 6: P(1) = 0.90, P(0) = 0.10

[0236] Bit 7: P(1) = 0.45, P(0) = 0.55

[0237] Bit 8: P(1) = 0.55, P(0) = 0.45

[0238] These probability values ​​represent the model's confidence that each bit is 0 or 1.

[0239] The probability value output by the bidirectional RNN is used as the initial extrinsic information and processed in combination with the received noisy Turbo code sequence.

[0240] The Max-Log-MAP algorithm is used to calculate the forward recursion, backward recursion and branch metrics and evaluate all possible paths.

[0241] For example, for bit 1, the Max-Log-MAP algorithm selects the most likely path (assuming it is 1) based on the probability values ​​P(1)=0.75 and P(0)=0.25, combined with the received noisy signal.

[0242] The above process is repeated for each bit to generate preliminary hard decisions and new external information.

[0243] The extrinsic information generated by the first component decoder is shuffled through an interleaver to disperse potential continuous errors.

[0244] Assume that the interleaved external information sequence is:

[0245] E'(1)=E(4)

[0246] E'(2)=E(7)

[0247] E'(3)=E(2)

[0248] E'(4)=E(5)

[0249] E'(5)=E(8)

[0250] E'(6)=E(3)

[0251] E'(7)=E(6)

[0252] E'(8)=E(1)

[0253] Similar to the first component decoder, the second component decoder also uses the Max-Log-MAP algorithm to process the interleaved data.

[0254] According to the interleaved extrinsic information and the received noisy Turbo code sequence, all possible paths are evaluated again and new extrinsic information is generated.

[0255] For example, for the interleaved bit 1 (actually corresponding to the original bit 4), the Max-Log-MAP algorithm will select the most likely path (assuming it is 1) based on the interleaved external information and the noisy signal.

[0256] The whole process is repeated for multiple iterations, with the external information updated at each iteration, until a predetermined number of iterations is reached or certain convergence conditions are met.

[0257] In each round of iteration, the first component decoder and the second component decoder work alternately, gradually reducing the bit error rate (BER) and improving decoding accuracy.

[0258] For example, in the second iteration, the first component decoder uses the updated extrinsic information from the second component decoder for processing, and then interleavedly passes it to the second component decoder again.

[0259] Assuming that after several rounds of iterations, the system reaches the predetermined convergence condition, we can generate the final hard decision from the result of the last iteration:

[0260] Bit 1:1

[0261] Bit 2: 0

[0262] Bit 3:1

[0263] Bit 4:1

[0264] Bit 5: 0

[0265] Bit 6:0

[0266] Bit 7:1

[0267] Bit 8:0

[0268] These hard decisions constitute the final decoding result, which should theoretically be as close as possible to the original transmitted information (10110010).

[0269] Furthermore, soft information can be extracted from the final iteration results for further analysis or as feedback to improve future transmissions. For example, if the probability of a certain bit is consistently high across multiple iterations, the decoding result for that bit can be considered more reliable.

[0270] It should be noted that in specific implementation scenarios, the above scheme can also be used to dynamically determine whether to continue iterations based on performance metrics (such as bit error rate (BER) or frame error rate (FER)) after each iteration. If performance improvement is not significant after a certain iteration, the iteration process can be terminated early, thereby saving computing resources. For example, an intelligent stopping criterion can be introduced, such as automatically terminating the iteration when the change in decoding results between consecutive iterations is less than a certain threshold, ensuring neither premature termination nor excessive resource waste.

[0271] In specific implementation scenarios, the Max-Log-MAP algorithm can also be used to weight the metrics of different branches based on the above solution, giving higher weights to branches with higher confidence (the probability values ​​provided by the bidirectional RNN), thereby guiding the algorithm to prefer these paths. In addition to selecting the optimal path, several suboptimal paths can be retained and their likelihood re-evaluated in subsequent iterations, increasing the chances of finding the global optimal solution.

[0272] In specific implementation scenarios, building on the above approach, more detailed adjustments can be made to the external information updates during each iteration. For example, nonlinear transformations or other advanced methods can be used to optimize the quality of the external information and enhance its impact on the final decoding results. A feedback mechanism can also be established to allow the second-round decoder to provide feedback to the first-round decoder, allowing the next round to better utilize this information for path selection and metric calculation.

[0273] In specific implementation scenarios, building on the above approach, a neural network specifically for path selection can be trained. This network receives all possible paths and their associated metrics as input and outputs a recommendation for the optimal path. This approach can help the Max-Log-MAP algorithm converge to the optimal solution more quickly. A joint training framework can be designed to enable the bidirectional RNN and Max-Log-MAP algorithms to be trained together within the same framework, mutually reinforcing each other and improving overall performance.

[0274] In specific implementation scenarios, the soft information generated by the bidirectional RNN can be refined based on the above solution, for example, by using smoothing filtering or local weighted averaging to enhance its stability and reduce the impact of noise. Soft information from different sources (such as the probability values ​​output by the bidirectional RNN and the soft information generated by the Max-Log-MAP algorithm) can be integrated to generate a more accurate final decoding result by comprehensively considering the advantages of both.

[0275] In some embodiments of the present application, the binary random bit stream is generated as the original information, and a Turbo code sequence is generated by two recursive systematic convolutional code component encoders, specifically:

[0276] Generate a binary random bit stream as the original information, with a frame length of N;

[0277] The original information passes through a first recursive systematic convolutional code encoder to output a forward coded sequence;

[0278] The original information is disrupted by an interleaver to generate a randomly arranged bit stream;

[0279] The interleaved information is passed through a second recursive systematic convolutional code encoder to output a backward coded sequence;

[0280] The original information, the forward coding sequence and the backward coding sequence are combined to form the Turbo code sequence.

[0281] As mentioned above, first, a binary random bit stream needs to be generated, which represents the original information to be transmitted. In practical applications, this information can be the result of digital processing of any form of data (such as text, images, etc.).

[0282] Assume that it is necessary to generate a binary random bit stream of length N. For example, if N=8, the bit stream that may be generated is 10110010.

[0283] This bit stream is completely random and is used to simulate various data patterns in the real world.

[0284] The original information is encoded using the first Recursive Systematic Convolutional Code (RSC) encoder to increase redundant information and improve error correction capability.

[0285] The generated raw binary bit stream is input into the first RSC encoder. The RSC encoder is a special convolutional encoder with a feedback path, which means that the output at the current moment depends not only on the current input bit, but also on the previous internal state.

[0286] For each input bit, the encoder produces one or more output bits. For example, given an input bit stream of 10110010, the encoder will calculate the corresponding output bit stream based on its internal state and a specific algorithm.

[0287] The output is called the forward coded sequence. Suppose the output sequence of the first encoder is 11 00 11 10 0010 10 01.

[0288] To enhance error correction capabilities, especially against burst errors, the original information needs to be interleaved. Interleaving disrupts the order of the bit stream, dispersing potential consecutive errors and facilitating correction during subsequent decoding.

[0289] An interleaver is used to rearrange the original bit stream. Interleaving rules can be designed according to specific needs. Common ones include block interleaving and convolutional interleaving.

[0290] For example, the original bit stream 10110010 may become 11001010 after interleaving. The purpose of this is that even if continuous errors occur during transmission, these errors will be scattered to different locations instead of being concentrated in the same segment of data.

[0291] The interleaved information is encoded using a second recursive systematic convolutional code encoder to further increase the redundancy.

[0292] The interleaved bit stream is input to the second RSC encoder. Although the structure is the same, the output coded sequence will be different because the input is an interleaved bit stream.

[0293] Similarly, for each input bit, the encoder generates a corresponding output bit. Suppose the interleaved bit stream 11001010 passes through the second encoder and the output sequence is 11 10 00 11 01 10 10 00.

[0294] Finally, the original information, the forward coding sequence and the backward coding sequence are combined to form a complete Turbo code sequence.

[0295] A turbo code sequence typically consists of the three parts mentioned above: the original information, the forward coded sequence, and the backward coded sequence. However, in actual transmission, only the coded sequences (i.e., the forward and backward coded sequences) are usually sent, while the original information can be recovered at the receiving end through deinterleaving and decoding.

[0296] For example, suppose there are three sequences:

[0297] Original message: 10110010

[0298] Forward encoding sequence: 11 00 11 10 00 10 10 01

[0299] Backward encoding sequence: 11 10 00 11 01 10 10 00

[0300] These sequences are combined to form a Turbo code sequence. Although the specific combination can be adjusted according to the actual application scenario, in general, only the forward and backward code sequences are transmitted.

[0301] In some embodiments of the present application, the preprocessing of the Turbo code sequence and inputting it into the bidirectional PNN model for processing to obtain an output feature vector is specifically as follows:

[0302] Transmitting the Turbo code sequence through a noisy channel to output a noisy Turbo code sequence;

[0303] Split the noisy Turbo code sequence into forward code, backward code and original information;

[0304] Standardize or normalize the data and output the preprocessed noisy Turbo code sequence as the model input;

[0305] Input the preprocessed noisy Turbo code sequence in chronological order, process it moment by moment in the forward RNN, and output the forward hidden state;

[0306] Input the sequence in reverse time order, process it moment by moment in the backward RNN, and output the backward hidden state;

[0307] The forward hidden state and the backward hidden state are concatenated to form a feature vector that integrates the context information, and the output feature vector of the bidirectional RNN is output.

[0308] As described above, various interference conditions that may be encountered in actual communication environments, such as signal attenuation and noise, are simulated. Consider a Turbo code sequence consisting of the original information, a forward coded sequence, and a backward coded sequence. This Turbo code sequence is transmitted over a simulated noisy channel, subject to various types of noise during transmission, such as white Gaussian noise (AWGN) and Rayleigh fading. The resulting output is a noisy Turbo code sequence, in which each bit may be subject to varying degrees of noise interference.

[0309] For subsequent processing, the received noisy Turbo code sequence needs to be split into its components. The received noisy Turbo code sequence usually only includes the forward coding sequence and the backward coding sequence (and in some cases, the original information), because the original information is usually not sent directly in actual transmission.

[0310] Assume the following noisy Turbo code sequence:

[0311] Forward encoding sequence: [1.1,-0.1,-0.2,0.9,0.1,1.05,0.95,-0.05]

[0312] Backward encoding sequence: [1.05,0.95,-0.1,1.05,0.95,1.05,0.95,-0.05]

[0313] The forward coding sequence and the backward coding sequence are extracted separately and prepared for further processing.

[0314] In order to ensure that the data input to the neural network is distributed uniformly and stably, the data needs to be standardized or normalized.

[0315] Standardization or normalization can make the data distributed in a specific range (such as [-1, 1] or [0, 1]), which helps speed up the training process and improve the stability of the model.

[0316] Assume that we choose to normalize the data to the interval [-1, 1]. For the first element 1.1 in the forward encoding sequence, after normalization, it becomes 0.9 (the specific value depends on the specific normalization method).

[0317] All elements are processed similarly, and finally the standardized forward coding sequence and backward coding sequence are obtained:

[0318] Normalized forward encoding sequence: [0.9,-0.6,-0.7,0.4,-0.6,0.95,0.45,-0.6]

[0319] Normalized backward encoding sequence: [0.95, 0.45, -0.6, 0.95, 0.45, 0.95, 0.45, -0.6]

[0320] The forward RNN is used to process the normalized forward encoding sequence to capture the temporal dependencies in the sequence.

[0321] The normalized forward encoding sequence is input into the forward RNN one by one in chronological order. For example, 0.9 is input first, followed by -0.6, and so on.

[0322] At each time step, the forward RNN updates its internal state and calculates the output based on the current input and the previous state. This process generates a series of hidden states that contain the temporal dependency information of the sequence.

[0323] Ultimately, the forward RNN outputs a series of hidden states that represent the time-dependent features of the forward encoded sequence.

[0324] Use the backward RNN to process the normalized backward encoded sequence to capture the reverse time dependency in the sequence. Input the normalized backward encoded sequence into the backward RNN one by one in reverse time order. For example, first input -0.6, then 0.45, and so on. Similar to the forward RNN, the backward RNN also updates its internal state at each time step and calculates the output based on the current input and the subsequent state. This process also generates a series of hidden states, but they reflect the reverse time dependency of the sequence. Ultimately, the backward RNN outputs a series of hidden states that represent the time dependency characteristics of the backward encoded sequence.

[0325] Combining the hidden states of the forward and backward RNNs, a feature vector containing comprehensive contextual information is generated.

[0326] For each time step, the hidden state generated by the forward RNN is concatenated with the hidden state generated by the backward RNN. For example, if at a certain time step, the hidden state of the forward RNN is [0.3, 0.4] and the hidden state of the backward RNN is [0.5, 0.6], the concatenated feature vector will be [0.3, 0.4, 0.5, 0.6]. Repeating this concatenation operation for all time steps, we ultimately obtain a set of feature vectors that incorporate both previous and next contextual information. These feature vectors contain rich contextual information, which helps subsequent layers better understand and process the input data.

[0327] In some embodiments of the present application, the output feature vector is standardized by a batch normalization layer, and a fully connected layer and a Sigmoid activation function are used to output a decoding result probability value, specifically:

[0328] performing mean and variance normalization on the output feature vector;

[0329] Calculate the linear combination through the fully connected layer and output the log-likelihood ratio of the decoding result;

[0330] The log-likelihood ratio is mapped to the interval [0, 1] using a Sigmoid function to output a decoding result probability value.

[0331] As mentioned above, ensuring that the data distribution input to subsequent layers is consistent and stable helps speed up the training process and improve the stability of the model.

[0332] Calculate the mean and variance of the output feature vectors of all samples in the current batch.

[0333] Assume that there is a batch of output feature vectors, and their mean is μ and variance is σ. 2 .

[0334] For each element in the eigenvector, normalize it using the following method: (x-μ) / √σ 2 , where x is the original eigenvalue.

[0335] For example, if an eigenvalue is 2.5, and the mean μ = 0.5, the variance σ 2 =1.2, then the standardized value is (2.5-0.5) / √1.2≈1.83.

[0336] In this way, each eigenvalue is adjusted to be close to the standard normal distribution (mean 0, variance 1), making the data distribution more uniform and stable.

[0337] The normalized feature vector is converted into a form suitable for the classification task, and the log-likelihood ratio (LLR) of each bit is calculated.

[0338] A fully connected layer is a neural network layer that allows all neurons in each layer to be connected to all neurons in the previous layer, thereby achieving feature recombination and mapping.

[0339] In this layer, each input feature is assigned a weight and added with a bias term to form a new output value. These weights and bias terms are learned during the training process.

[0340] For example, suppose the normalized eigenvector is [1.83, -1.58, 0.27, -0.98, 0.81, 0.36, -1.45, 0.18], the weight matrix of the fully connected layer is [w1, w2, ..., w8], and the bias term is b.

[0341] Each eigenvalue is multiplied by its corresponding weight, added together, and a bias term is added to obtain a new scalar value, the log-likelihood ratio (LLR) of that bit. For example, for the first bit, its LLR might be 1.83*w1+(-1.58)*w2+...+0.18*w8+b.

[0342] These LLR values ​​reflect the model's confidence in whether each bit is 0 or 1, with positive values ​​tending to indicate that the bit is 1 and negative values ​​tending to indicate that the bit is 0.

[0343] The log-likelihood ratio of the fully connected layer output is mapped to the interval [0,1] and converted into the probability value of each bit being 0 or 1.

[0344] The Sigmoid function is a nonlinear activation function with an S-shaped curve that can compress any real value to between (0,1).

[0345] For each bit's log-likelihood ratio (LLR), apply the Sigmoid function to convert it into a probability value. For example, if the LLR value of a bit is 1.826, after the Sigmoid function, its probability value is 1 / (1+exp(-1.826))≈0.86.

[0346] This means that the model believes that the bit is 1 with a probability of 86%, and otherwise it is 0 with a probability of 14%.

[0347] Repeating the above process for all bits ultimately yields a probability value for each bit being 0 or 1. These probabilities not only provide the basis for hard decisions but also contain soft decision information, i.e., the model’s confidence in the state of each bit.

[0348] In some embodiments of the present application, based on the decoding result probability value, the Max-Log-MAP algorithm is cascaded with the component decoder of the bidirectional RNN to obtain the decoding result, specifically:

[0349] The probability values ​​based on the first decoding result are rearranged through an interleaver and input into the second component decoder;

[0350] The two component decoders alternately update external information and optimize path selection using the Max-Log-MAP algorithm;

[0351] Calculate the forward probability and backward probability, and optimize the decoding path based on the log-likelihood ratio of the noisy channel;

[0352] Output the decoding results after multiple iterations of optimization.

[0353] As described above, the extrinsic information (ie, log-likelihood ratios or probability values) generated by the first component decoder is shuffled through the interleaver so that the information can be used for further processing in the second component decoder.

[0354] Assume that the bidirectional RNN model has generated decoding result probabilities after the first iteration. For example, for an 8-bit bit stream, the probabilities might be [0.75, 0.30, 0.80, 0.60, 0.20, 0.90, 0.45, 0.55]. These probabilities represent the model's confidence that each bit is 0 or 1. An interleaver is used to rearrange these probabilities to disperse potential consecutive errors. For example, the original bit stream might be [a, b, c, d, e, f, g, h], but after interleaving, it might become [d, g, b, e, h, c, f, a]. These rearranged probabilities are passed as the new input to the second component decoder.

[0355] The two component decoders work alternately, gradually updating the external information and optimizing the path selection through the Max-Log-MAP algorithm to approach the optimal solution.

[0356] The first component decoder receives the noisy Turbo code sequence and the initial probability value, calculates the forward recursion, backward recursion and branch metric using the Max-Log-MAP algorithm, evaluates all possible paths, and outputs preliminary hard decisions and external information.

[0357] External information contains soft information about the correctness of each bit (i.e., probability value), which is used to guide subsequent path selection.

[0358] The extrinsic information generated by the first component decoder is shuffled through an interleaver and then passed to the second component decoder.

[0359] The second component decoder receives the interleaved extrinsic information and applies the Max-Log-MAP algorithm again to process it, generates new extrinsic information and reverse interleaves it back to the original order.

[0360] The whole process is repeated for multiple iterations, with the external information updated at each iteration, until a predetermined number of iterations is reached or certain convergence conditions are met.

[0361] In each iteration, the Max-Log-MAP algorithm is used to calculate the forward probability and backward probability, and combined with the log-likelihood ratio (LLR) of the noisy channel to optimize the path selection and gradually approach the optimal solution.

[0362] The cumulative probability of each state is calculated from the beginning to the end of the sequence to form a forward probability matrix.

[0363] The cumulative probability of each state is calculated from the end of the sequence to the beginning to form a backward probability matrix.

[0364] According to the characteristics of the received noisy signal and the noise channel (such as Gaussian white noise), the log-likelihood ratio (LLR) of each branch is calculated as an important basis for path selection.

[0365] Combining the forward probability, backward probability and branch metric, the most likely path is selected as the current best estimate.

[0366] According to the result of path selection, the external information is updated and passed to the next component decoder.

[0367] After several iterations, the system outputs the final decoding result, which should be as close as possible to the original information sent.

[0368] Each iteration will gradually reduce the bit error rate (BER) and improve decoding accuracy.

[0369] When the predetermined number of iterations is reached or certain convergence conditions are met, the system stops iterating and generates a final hard decision (Hard Decision) based on the result of the last iteration, that is, the specific value of each bit (0 or 1).

[0370] For example, suppose that after several iterations, the system arrives at a final hard decision of 10110010, which should be very close to the original information sent.

[0371] In addition, soft information can be extracted from the final iteration results for further analysis or as feedback information to improve future transmissions.

[0372] In some embodiments of the present application, after obtaining a decoding result by cascading a Max-Log-MAP algorithm and a component decoder of a bidirectional RNN based on the decoding result probability value, the method further includes:

[0373] Converting the decoding result into a binary bit stream through a threshold;

[0374] The result is compared with the original information to calculate the bit error rate.

[0375] As mentioned above, the probability values ​​obtained from the Max-Log-MAP algorithm and the bidirectional RNN component decoder cascade are converted into specific binary bits (0 or 1) for subsequent comparison and analysis.

[0376] Suppose we have a sequence of probabilities for each bit being 0 or 1. For example, for an 8-bit bit stream, the probabilities might be [0.75, 0.30, 0.80, 0.60, 0.20, 0.90, 0.45, 0.55].

[0377] In order to convert these probability values ​​into a binary bit stream, a threshold needs to be set. Usually, the threshold is set to 0.5.

[0378] For each probability value, if it is greater than or equal to the threshold, the corresponding bit is determined to be 1; otherwise, it is determined to be 0.

[0379] For example, 0.75>=0.5, so the first bit is judged to be 1;

[0380] 0.30<0.5, so the second bit is judged to be 0;

[0381] And so on, until all probability values ​​are converted into binary bits.

[0382] After the above steps, the resulting binary bit stream may be [1,0,1,1,0,1,0,1].

[0383] By comparing the converted binary bit stream with the original transmitted information, the bit error rate (BER) is calculated to evaluate the performance and accuracy of the entire system.

[0384] First, you need to make sure you have the original information as a reference. Suppose the original information is 10110010.

[0385] The decoded and converted binary bit stream is compared with the original information bit by bit. Specifically, every bit is checked to see if they are identical.

[0386] In this example, the converted bit stream is [1,0,1,1,0,1,0,1], while the original information is 10110010.

[0387] Comparing the two sequences, we can see that bits 6 and 8 are different (a 1 in the converted bit stream versus a 0 in the original information).

[0388] The bit error rate is defined as the number of erroneous bits divided by the total number of bits. In this example, there are 2 erroneous bits (bits 6 and 8) and the total number of bits is 8.

[0389] Therefore, the bit error rate is 2 / 8 = 0.25 or 25%.

[0390] This bit error rate can be used to evaluate the system's performance under current channel conditions. A lower bit error rate indicates higher system accuracy and reliability, while a higher bit error rate indicates potential room for improvement, such as adjusting coding parameters, optimizing model structure, or improving noise processing methods.

[0391] A second aspect of the present application provides a deep learning-based duobinary turbo decoding system according to any one of the first aspects, including:

[0392] An encoding module, configured to generate a binary random bit stream as original information and generate a turbo code sequence through two recursive systematic convolutional code component encoders;

[0393] A preprocessing module, configured to preprocess the Turbo code sequence and input the preprocessed data into a bidirectional PNN model for processing to obtain an output feature vector;

[0394] A decoding module is configured to perform normalization based on the output feature vector through a batch normalization layer, and output a decoding result probability value using a fully connected layer and a Sigmoid activation function;

[0395] The iterative optimization module is used to obtain a decoding result based on the decoding result probability value by using the Max-Log-MAP algorithm and the component decoder cascade of the bidirectional RNN.

[0396] According to one embodiment of the present application, the encoding module is specifically:

[0397] Generate a binary random bit stream as the original information, with a frame length of N;

[0398] The original information passes through a first recursive systematic convolutional code encoder to output a forward coded sequence;

[0399] The original information is disrupted by an interleaver to generate a randomly arranged bit stream;

[0400] The interleaved information is passed through a second recursive systematic convolutional code encoder to output a backward coded sequence;

[0401] The original information, the forward coding sequence and the backward coding sequence are combined to form the Turbo code sequence.

[0402] According to one embodiment of the present application, the preprocessing module is specifically:

[0403] Transmitting the Turbo code sequence through a noisy channel to output a noisy Turbo code sequence;

[0404] Split the noisy Turbo code sequence into forward code, backward code and original information;

[0405] Standardize or normalize the data and output the preprocessed noisy Turbo code sequence as the model input;

[0406] Input the preprocessed noisy Turbo code sequence in chronological order, process it moment by moment in the forward RNN, and output the forward hidden state;

[0407] Input the sequence in reverse time order, process it moment by moment in the backward RNN, and output the backward hidden state;

[0408] The forward hidden state and the backward hidden state are concatenated to form a feature vector that integrates the context information, and the output feature vector of the bidirectional RNN is output. A third aspect of the present application provides an electronic device, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, the cooking control method of any of the embodiments of the second aspect is implemented.

[0409] Figure 2 An example of a physical structure diagram of an electronic device is shown below. Figure 2 As shown, the electronic device may include: a processor 810, a communication interface 820, a memory 830, and a communication bus 840, wherein the processor 810, the communication interface 820, and the memory 830 communicate with each other via the communication bus 840. The processor 810 may call the logic instructions in the memory 830 to execute a deep learning-based duobinary turbo decoding method in any embodiment of the first aspect above, the method comprising:

[0410] Generate a binary random bit stream as the original information and generate a turbo code sequence through two recursive systematic convolutional code component encoders;

[0411] Preprocessing the Turbo code sequence and inputting it into a bidirectional PNN model for processing to obtain an output feature vector;

[0412] Based on the output feature vector, the batch normalization layer is used to perform normalization, and the fully connected layer and the Sigmoid activation function are used to output the probability value of the decoding result;

[0413] Based on the decoding result probability value, the Max-Log-MAP algorithm is cascaded with the component decoders of the bidirectional RNN to obtain the decoding result.

[0414] In addition, the logic instructions in the above-mentioned memory 830 can be implemented in the form of a software functional unit and can be stored in a computer-readable storage medium when sold or used as an independent product. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or the part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for enabling a computer device (which can be a personal computer, server, or network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0415] Example 2

[0416] like Figure 3 、 Figure 4 、 Figure 5 and Figure 6 A deep learning-based duobinary Turbo decoding method is shown, characterized by the following: The core feature of this patent is the application of deep learning technology to the decoding process of duobinary Turbo codes. By constructing and optimizing deep neural network models, particularly convolutional neural networks (CNNs), recurrent neural networks (RNNs), and other suitable neural network structures, intelligent parsing and decoding of Turbo code data is achieved. The method includes the following steps:

[0417] (1) The input information is input into the bidirectional RNN neural network (BRNN) in both forward and reverse order, and will be expanded in time sequence. The hidden layer contains two nodes, which will receive information from the previous moment as well as the next moment.

[0418] (2) After the input sequence is RSC-encoded, it passes through the noisy channel. The neural network takes the noisy signals of the previous and next moments in the time series as the input to the BRNN layer, stores the signal features of the previous, next, and current moments, and calculates the output of the next moment through the updated weights of each layer. The BN (Batch Normalization) layer is connected after the bidirectional RNN to preprocess the data to enter the output layer and accelerate the convergence of the network. The output layer is a fully connected network used to calculate the decoding result.

[0419] (3) The receiving end constructs an RNN component decoder and cascades two identical component decoders through an interleaver to achieve information interaction of the decoding results. The noisy information is trained end-to-end through a neural network. When receiving, the feature of the noisy information is extracted and the output decoding result is calculated.

[0420] 2. The Turbo decoding based on deep learning in this invention adopts a bidirectional RNN (Recurrent Neural Network) structure. Figure 3 As shown in the figure, this design does increase the amount of computation compared to the traditional unidirectional RNN network, which is approximately doubled, because the bidirectional RNN considers both the forward and reverse information of the sequence.

[0421] (2.1) For a recurrent neural network (RNN), x is the input, y is the output, and h is the hidden layer. The loop is reflected in the update process of the hidden layer h. U, W, and V represent the weights of the output of different layers, and the weights of the RNN are the same at every moment.

[0422] (2.2) Specifically, bidirectional RNNs can simultaneously extract features from input sequences in both the forward and backward directions. This bidirectional processing mechanism enables the network to more comprehensively capture contextual information in the data, including future (in the backward process) and past (in the forward process) dependencies. This capability is particularly suitable for tasks that require simultaneous consideration of both contextual information, such as sequence labeling in natural language processing and temporal modeling in speech recognition, as well as the decoding process of Turbo codes.

[0423] 3. The core architecture of a Turbo code consists of two recursive systematic convolutional code (RSC) component encoders. Due to the characteristics of recursive systematic convolutional codes, their encoders use a serial structure. During the encoding process, each output bit depends not only on the input at the current moment, but is also closely related to the register state at the previous moment. Recurrent neural networks (RNNs) are able to retain internal state information, or "memory," after each calculation. This property makes them ideal for calculating the output at the next moment, and they exhibit excellent structural adaptability, particularly when processing sequential data. Therefore, during the system encoding stage, RNNs can be used to construct the component convolutional encoders of Turbo codes. By cascading two such component encoders, a complete Turbo coding architecture is formed.

[0424] (3.1) When the (2,1,2) recursive systematic convolutional code is used as the component code of the Turbo code, the hidden layer state is represented as st = (s t1 ,s t2 ), the encoding process starts by initializing the hidden layer state to (0,0). For each binary codeword x in the input frame t1 , the encoder first calculates the output vector (y t1 ,y t2 ), where y t1 Directly equal to x t1 , and y t2 is x t1 and the first component s of the hidden layer state at the previous moment t1 The XOR result is as follows

[0425]

[0426] (3.2) Then, the hidden layer state is updated to (st +1，1 ,s t+1,2 ), where s t+1,1 Is the second component s of the hidden layer state at the previous moment t2 with x t1 The XOR result, s t+1,2 Then directly inherit the s of the previous moment t1 , as follows:

[0427]

[0428] This process is repeated for each symbol in the input frame until the entire frame is encoded.

[0429] 4. Due to the characteristics of its RSC component encoder, such as Figure 1 As shown in Figure 2, the complete dual binary turbo decoding is composed of two bidirectional RNN component decoders with the same structure cascaded. s , check sequence yp On the one hand, it directly enters component decoder 1 and waits for subsequent processing, and on the other hand, it enters component decoder 2 after interleaving and waits for subsequent processing. Initialize the parameters U, V, W of each layer of the two RNN component decoders, and at the first iteration, the prior information La of the standard Max_Log_Map algorithm is used. 1 To estimate the posterior probability p(La) of each input bit in component decoder 1 1 |(y s ,y p )), then y s and y p Enter RNN component decoder 1, and La 1 The external information Le of the output component decoder 1 is processed by network calculation 1 , and the reliability information of the decoding result is calculated according to the output of the BRNN layer in the fully connected network; at the same time, the interleaved system sequence y s , check sequence y p and Le 1 The same calculation process is performed as in the RNN component decoder 2, and the output Le 2 and reliability information for RNN component decoder 2. After a frame is completed, the next iteration begins. After several iterations, the soft decision information of the two sub-decoders gradually stabilizes, and the posterior probability ratio of the input message symbols gradually approaches the ratio when using the Maximum Likelihood Decoding (MLD) algorithm. Thus, the bidirectional RNN Turbo decoding model performs iterative bit decoding and outputs the decoding result after stabilization.

[0430] 5. The turbo decoding method of the present invention uses the Max-Log-MAP algorithm as the key algorithm in decoding. Its steps mainly include initialization, forward recursion, backward recursion, calculation of branch metrics, calculation of log-likelihood ratios (LLRs), and iterative update. The specific steps are as follows:

[0431] (5.1) At the beginning of each iteration cycle, the state values ​​of all nodes are initialized to the same probability, and the log-likelihood ratio (LLR) values ​​of all edges are initialized to 0. This is to provide a unified starting point for subsequent recursive calculations.

[0432] (5.4) For each path (i.e., each node branch), the branch metric is calculated based on the received signal and prior information. This step is to evaluate the credibility of the path in the decoding process. The specific formula is as follows:

[0433]

[0434] in is the prior information of symbol i at time k. For the Max_Log_MAP algorithm, the channel value Lc is generally set to 2. To actually receive the data, is the original bit corresponding to it. k is the verification information actually received, is the corresponding check bit.

[0435] (5.2) Based on the received signal sequence and prior information, the forward state metric of each node is calculated. This step is performed in the logarithmic domain, using addition instead of multiplication, and updating the state metric by comparing the metrics of different paths. The specific formula is as follows:

[0436] α k (s)=max(α k-1 (s′)+γ k (s′,s))

[0437] (5.3) The backward state metric is similar to the forward recursion, but in the opposite direction, starting from the end of the sequence and working forward, to calculate the backward state metric of each node. Again, this is done in the logarithmic domain, using addition to simplify the calculation process. The specific formula is as follows:

[0438] β k (s)=max(β k-1 (s′)+γ k (s′,s))

[0439] (5.5) Using the forward state metric, backward state metric, and branch metric, calculate the extrinsic information (LLE) of each bit. The specific formula is as follows:

[0440]

[0441] (5.6) The log-likelihood ratio (LLR) of each bit can be calculated from the external information. The LLR value reflects the probability ratio of the received bit to be "0" or "1" and is an important basis for decoding decisions. The specific formula is as follows:

[0442]

[0443] in

[0444]

[0445] L a (u k =3)=L e (u k =3)

[0446] (5.7) The calculated LLR values ​​are used as new prior information and fed into another component decoder for iterative decoding. The two component decoders exchange information with each other through the interleaver and deinterleaver, and continuously iterate until the predetermined number of iterations is reached or the convergence condition is met.

[0447] (5.8) After the iteration is completed, a hard decision is made based on the final calculated LLR value to determine the decoding result of each bit and output the final decoded sequence.

[0448] 6. The RNN network dataset is divided into two parts: training dataset and test dataset.

[0449] (6.1) To construct the training dataset, we first generate a series of binary random bit streams with a frame length of N at the transmitter. After encoding, these bit streams are processed to obtain the sequence {x i}. Then, under the condition of 0dB signal-to-noise ratio, we send these encoded sequences {x i} to simulate the background noise in the actual communication environment. Furthermore, in order to enhance the complexity and diversity of the dataset, we set a random number p between (0, 0.1) and, under a signal-to-noise ratio of -1dB, apply a random number p with probability p and variance 0 to the sequence to which Gaussian white noise has been added. This process simulates the sudden noise events that may occur during communications. Through the above steps, we successfully generated a frame of data samples. Repeating this process multiple times yielded a total of 1,000 data samples with varying noise characteristics. These samples together constitute the training dataset used to train the deep learning model.

[0450] (6.2) The test dataset is constructed independently of the training dataset to comprehensively evaluate the performance of the model under different noise conditions. The test dataset is divided into two parts, simulating Gaussian white noise and burst noise environments respectively. For the Gaussian white noise test set, the transmitter randomly generates a binary random bit stream with a frame length of N and encodes it to obtain the sequence {x i}. Subsequently, within the SNR range of 0 to 3dB, multiple SNR points were set at 0.5dB intervals. Gaussian white noise was added to the encoded sequence {xi} at each SNR point, generating seven sets of data samples with varying noise levels. These seven sets of samples were stored under their own sample labels, each containing 1000 data samples to ensure the adequacy and accuracy of the test.

[0451] For the burst noise test set, we first copy 11 sets of Gaussian white noise data sets (these data sets are different from the above Gaussian white noise test set, but have similar generation methods). Then, based on each set of data sets, we set p to a random number in the range of (0, 0.1) and add a probability of p and a variance of 0.01 to the information sequence under a -1dB signal-to-noise ratio. In this way, each dataset contains a complex noise environment composed of Gaussian white noise and burst noise, simulating the more severe noise conditions that may be encountered in actual communications. This method constructs a test dataset for evaluating the performance of the model in burst noise environments.

[0452] 7. The specific training steps of the RNN network dataset are:

[0453] (7.1) At time t, the noise-superimposed sequence {x t The current bit in the data is fed into the neural network one by one. The network performs calculations for each input bit and predicts the output at the next moment. The network then compares the predictions with the original (noise-free) information to assess the accuracy of the predictions and updates its internal parameters accordingly to optimize performance. During this process, the hidden layer uses the tanh function as the activation function, which is centered around zero and helps accelerate network convergence.

[0454]

[0455] The hidden state of the network at time t is denoted by S t express:

[0456] S t =tanh(Ux t +WS t -1)

[0457] As for the output layer, it usually applies an activation function to transform the output of the hidden layer in order to generate a final prediction suitable for a specific task (such as classification, regression, etc.). In classification tasks, the softmax function is one of the commonly used activation functions in the output layer because it can convert the output of the hidden layer into a probability distribution, thereby facilitating category judgment. The specific formula is:

[0458]

[0459] Therefore, {yt} is the output of the network at time t and can be expressed as:

[0460] y t =softmax(VS t )

[0461] (7.2) During the training process, the network uses the predicted value yt (i.e., the estimate of the input features at time t+1) and the actual input x t+1 The error between is used as feedback to adjust the parameters through gradient descent. In order to improve the optimization efficiency, the Adam algorithm is used here. This algorithm not only considers the first-order momentum (i.e., the exponential moving average of the gradient), but also introduces the second-order momentum (i.e., the exponential moving average of the square of the gradient), so that the learning rate of each parameter can be adaptively adjusted and intelligent optimization can be performed according to the frequency and amplitude of parameter updates. Assuming w t is the parameter to be optimized at time t, g t It represents the loss function at time t with respect to w t Gradient Then the first-order momentum and second-order momentum are as follows:

[0462] m t =φ(g1,g2,……,g t )

[0463] V t =ψ(g1,g2,……,g t )

[0464] So the descent gradient at the current moment is:

[0465]

[0466] The update method of parameters and momentum at time t+1 is as follows:

[0467] w t+1 =w t -η t

[0468]

[0469] Among them, α is the learning rate, which is initialized to 0.001, β1 and β2 are two constants, β1 is set to 0.9 and β2 is set to 0.999.

[0470] When processing neural networks, we use batch processing to gradually train the model, with the batch size set to 100. To more effectively extract features from potentially noisy datasets, we introduce the concept of epochs, which refers to the number of times the same batch of data is repeatedly trained. Initially, we set the epoch value to 50, but to account for the risk of overfitting, we adjust the learning rate α at different stages of the epoch. The specific adjustment strategy is as follows:

[0471] When the number of epochs is less than or equal to 10, the learning rate α is set to 0.01;

[0472] When the epoch number is between 10 and 20, the learning rate α is adjusted to 0.001;

[0473] When the number of epochs is between 20 and 30, the learning rate α is further reduced to 0.0001;

[0474] When the number of epochs exceeds 30, the learning rate α is set to an extremely low 0.00001.

[0475] In addition, to optimize the training process, we introduced an early stopping mechanism: if the loss function value (loss) of the model for training the same batch of data does not change significantly within 10 consecutive epochs, the training process will be terminated early.

[0476] For the final output of the model, since it is a binary classification problem, we use the Binary Cross-Entropy function as the loss function to measure the difference between the model prediction and the actual label. Its mathematical expression is:

[0477]

[0478] In the RNN model, input data enters as a three-dimensional tensor [batch_size, seq_len, input_dim]. Batch_size = 100 processes 100 samples at a time, sequence_length is set to 120 and 1200 to explore the impact of different sequence lengths on learning efficiency, and input_dim = 1 is used for single features in time series. After processing by the RNN layer, the data is normalized by a batch normalization layer and then passed to a fully connected network for further feature extraction and output calculation. Finally, a sigmoid activation function maps the output of the fully connected network to the interval [0, 1], serving as a direct estimate of each information bit. This effectively improves decoding efficiency and avoids the complex iterative calculation of the posterior probability.

[0479] Anything not described in this application can be achieved by adopting or drawing on existing technologies.

[0480] The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other. Each embodiment focuses on the differences from other embodiments.

[0481] The foregoing is merely an embodiment of the present application and is not intended to limit the present application. For those skilled in the art, the present application may have various modifications and variations. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present application should all be included in the protection scope of the present application.

Claims

1. A deep learning-based duobinary turbo decoding method, characterized in that: include: Generate a binary random bit stream as the original information and generate a turbo code sequence through two recursive systematic convolutional code component encoders; Preprocessing the Turbo code sequence and inputting it into a bidirectional PNN model for processing to obtain an output feature vector; Based on the output feature vector, the batch normalization layer is used to perform normalization, and the fully connected layer and the Sigmoid activation function are used to output the probability value of the decoding result; Based on the decoding result probability value, the Max-Log-MAP algorithm is cascaded with the component decoders of the bidirectional RNN to obtain the decoding result.

2. The method according to claim 1, characterized in that The binary random bit stream is generated as the original information, and a Turbo code sequence is generated through two recursive systematic convolutional code component encoders, specifically: Generate a binary random bit stream as the original information, with a frame length of N; The original information passes through a first recursive systematic convolutional code encoder to output a forward coded sequence; The original information is disrupted by an interleaver to generate a randomly arranged bit stream; The interleaved information is passed through a second recursive systematic convolutional code encoder to output a backward coded sequence; The original information, the forward coding sequence and the backward coding sequence are combined to form the Turbo code sequence.

3. The method according to claim 1, characterized in that The Turbo code sequence is pre-processed and input into the bidirectional PNN model for processing to obtain an output feature vector, specifically: Transmitting the Turbo code sequence through a noisy channel to output a noisy Turbo code sequence; Split the noisy Turbo code sequence into forward code, backward code and original information; Standardize or normalize the data and output the preprocessed noisy Turbo code sequence as the model input; Input the preprocessed noisy Turbo code sequence in chronological order, process it moment by moment in the forward RNN, and output the forward hidden state; Input the sequence in reverse time order, process it moment by moment in the backward RNN, and output the backward hidden state; The forward hidden state and the backward hidden state are concatenated to form a feature vector that integrates the context information, and the output feature vector of the bidirectional RNN is output.

4. The method according to claim 1, wherein Based on the output feature vector, the batch normalization layer is used to perform normalization, and the fully connected layer and the Sigmoid activation function are used to output the decoding result probability value, specifically: performing mean and variance normalization on the output feature vector; Calculate the linear combination through the fully connected layer and output the log-likelihood ratio of the decoding result; The log-likelihood ratio is mapped to the interval [0, 1] using a Sigmoid function to output a decoding result probability value.

5. The method according to claim 1, wherein Based on the decoding result probability value, the Max-Log-MAP algorithm is used in cascade with the component decoder of the bidirectional RNN to obtain the decoding result, which is specifically: The probability values ​​based on the first decoding result are rearranged through an interleaver and input into the second component decoder; The two component decoders alternately update external information and optimize path selection using the Max-Log-MAP algorithm; Calculate the forward probability and backward probability, and optimize the decoding path based on the log-likelihood ratio of the noisy channel; Output the decoding results after multiple iterations of optimization.

6. The method according to claim 1, characterized in that After obtaining the decoding result based on the decoding result probability value by cascading the Max-Log-MAP algorithm and the component decoder of the bidirectional RNN, the method further includes: Converting the decoding result into a binary bit stream through a threshold; The result is compared with the original information to calculate the bit error rate.

7. A deep learning-based duobinary turbo decoding system, characterized in that: include: An encoding module, configured to generate a binary random bit stream as original information and generate a turbo code sequence through two recursive systematic convolutional code component encoders; A preprocessing module, configured to preprocess the Turbo code sequence and input the preprocessed data into a bidirectional PNN model for processing to obtain an output feature vector; A decoding module is configured to perform normalization based on the output feature vector through a batch normalization layer, and output a decoding result probability value using a fully connected layer and a Sigmoid activation function; The iterative optimization module is used to obtain a decoding result based on the decoding result probability value by using the Max-Log-MAP algorithm and the component decoder cascade of the bidirectional RNN.

8. The system according to claim 7, characterized in that The encoding module is specifically: Generate a binary random bit stream as the original information, with a frame length of N; The original information passes through a first recursive systematic convolutional code encoder to output a forward coded sequence; The original information is disrupted by an interleaver to generate a randomly arranged bit stream; The interleaved information is passed through a second recursive systematic convolutional code encoder to output a backward coded sequence; The original information, the forward coding sequence and the backward coding sequence are combined to form the Turbo code sequence.

9. The system according to claim 7, wherein: The pre-processing module is specifically: Transmitting the Turbo code sequence through a noisy channel to output a noisy Turbo code sequence; Split the noisy Turbo code sequence into forward code, backward code and original information; Standardize or normalize the data and output the preprocessed noisy Turbo code sequence as the model input; Input the preprocessed noisy Turbo code sequence in chronological order, process it moment by moment in the forward RNN, and output the forward hidden state; Input the sequence in reverse time order, process it moment by moment in the backward RNN, and output the backward hidden state; The forward hidden state and the backward hidden state are concatenated to form a feature vector that integrates the context information, and the output feature vector of the bidirectional RNN is output.

10. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the program, the method according to any one of claims 1 to 6 is implemented.

Images