{'fraction_non_alphanumeric': 0.03299336788719835, 'fraction_numerical': 0.009697375020899516, 'mean_word_length': 4.558859975216852, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 7, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
High Rate Communication over One-Bit Quantized Channels via Deep Learning and LDPC Codes

This paper proposes a method for designing error correction codes by combining a known coding scheme with an autoencoder. Specifically, we integrate an LDPC code with a trained autoencoder to develop an error correction code for intractable nonlinear channels. The LDPC encoder shrinks the input space of the autoencoder, which enables the autoencoder to learn more easily. The proposed error correction code shows promising results for one-bit quantization, a challenging case of a nonlinear channel. Specifically, our design gives a waterfall slope bit error rate even with high order modulation formats such as 16-QAM and 64-QAM despite one-bit quantization. This gain is theoretically grounded by proving that the trained autoencoder provides approximately Gaussian distributed data to the LDPC decoder even though the received signal has non-Gaussian statistics due to the one-bit quantization.


I. INTRODUCTION
Popular error correction codes including turbo codes, low density parity check (LDPC) codes and polar codes produce error rates very close to the Shannon limit for linear additive white Gaussian noise (AWGN) channels. However, these codes often do not perform well under hardware constraints and/or impediments. Two key trends in wireless communication systems are the march towards higher carrier frequencies and a very large number of antennas, both of which will introduce increasingly non-ideal hardware constraints such as low-resolution quantization and other nonlinear distortions. Hence, designing an error correction code that is robust to such distortions is important for future communication systems, even if such distortions are analytically intractable.
In this paper, we propose a methodology to develop efficient error correction codes for one-bit quantization. The main reason behind the selection of this nonlinear channel model is associated with the fact that one-bit quantization brings severe nonlinearities. Thus, a channel code that can cope with one-bit quantization should be able to resist less severe nonlinearities. Furthermore, it is easy to model the nonlinearities due to one-bit quantization, which can be done by taking the sign of the real and imaginary part of the signals, unlike other RF nonlinearities. Our methodology relies on combining a state-of-the-art code that is optimized for a static linear AWGN channel (which can be seen as an outer code) with an autoencoder (which can be seen as an inner code) so as to capture the system dynamics via learning/training. This can also be interpreted as combining the current knowledge in coding theory with the recent advances in deep learning in an attempt to end up with novel error correction codes.
Employing a neural network for error correction codes dates back to late eighties. More precisely, [1] shows how to decode linear block codes. Similarly, the Viterbi decoder was implemented with a neural network for convolutional codes in the late nineties [2], [3]. A simple classifier is learned in these studies instead of a decoding algorithm. This leads to a training dataset that must include all codewords, which makes them infeasible for most codes due to the exponential complexity. Recently, it was shown that a decoding algorithm could be learned for structured codes [4], however this design still requires a dataset with at least 90% percent of the codebook, which limits its practicality to small block lengths. To learn decoding for large block lengths, [5] trained a recurrent neural network for small block lengths that can generalize well for large block lengths. Although there are many papers that propose a deep learning-based decoding algorithm, there are only a few papers that aim to learn an encoder [6], [7].
In this paper, we design an error correction code, i.e., learn an encoder-decoder pair for a severe nonlinear channel model: a one-bit quantized AWGN channel. For this purpose, we train an autoencoder, and then incorporate an LDPC code to this autoencoder. In the case of QPSK or BPSK modulation one-bit quantization corresponds to hard decision decoding and only leads to a few dB signal-to-noise-ratio (SNR) loss. However, for high order modulations one-bit quantization leads to a very poor error rate, since the real and the imaginary part of the signals carry more than one bit information. The closest paper to this work is [8], which proposed to integrate a turbo code to an autoencoder to handle the detrimental effects of onebit quantization for QPSK and 16-QAM signaling. The main difference of this paper is to (i) use an LDPC code instead of a turbo code; (ii) utilize a modified autoencoder architecture; and (iii) propose a simpler, but efficient training policy that gives us better error rate for high order modulations, e.g., 64-QAM can be operable for one-bit quantization at sufficiently low SNRs.
The main contributions of this paper are as follows. First, we propose sending symbols at a faster-than-Nyquist rate to have a large enough learning capacity for the autoencoder that is integrated with an LDPC code. Then, we theoretically show that with this transmission and the proposed autoencoder architecture (hat has infinite width neural layers) it is possible to provide Gaussian distributed data to the LDPC decoder despite the nonlinearities of one-bit quantization. In what follows, we evaluate the efficiency of our error correction code with simulations for practical finite layer widths. The proposed channel code can make high order modulations such as 16-QAM and 64-QAM operable even if one-bit quantization is employed. To be more precise, our code can approach the performance of the LDPC codes in 802.11n and DVB-S2 standards that decode unquantized samples without increasing bandwidth. This apparently brings significant spectral efficiency gain for low-resolution receivers by enabling high order modulations.

II. AUTOENCODER EMPOWERED ERROR CORRECTION CODING
Conventional error correction codes do not provide any guarantee to obtain almost zero bit error rate at sufficiently low SNRs for nonlinear channels or non-Gaussian noise. To have a low bit error rate for more challenging nonlinear environments, we propose to integrate an autoencoder with an existing error correction code. This results in a concatenated code such that the outer code is a known state-of-the-art code and the inner code is a learned or trained autoencoder. This idea is illustrated for an LDPC code in Fig. 1. In accordance with that, the input bits b n are first encoded with an LDPC encoder. This LDPC encoder produces a codeword c n that has B bits. This means that the LDPC encoder output block size is B. Then, these coded bits are modulated with an M -ary modulation method giving B/ log 2 (M ) symbols per codeword, which are represented as d n . The coded symbols d n are then given to the autoencoder.
Processing the entire symbols of a codeword with an autoencoder yields excessive computational complexity for large codeword lengths. For instance, taking a reasonable codeword length of 1000 as an input to an autoencoder yields millions of parameters. Therefore, these coded symbols are broken into small blocks of N , in which N B/ log 2 (M ). More precisely, a codeword is written in terms of the modulated symbols as where S = B/(N log 2 (M )) and For (1) each d i is processed separately, but with the same weights or parameters of the autoencoder. This means that a single set of weights (or a single autoencoder) is learned for all d i for i = 1, 2, · · · , S. This brings huge complexity savings. There are many alternatives for the autoencoder architecture. For simplicity, we utilize a few fully connected layers as was done in [8], [9]. Since the same weights are used for each block, the overall architecture can be considered as a onedimensional convolutional neural network with stride N . This autoencoder architecture is given in Table I. In addition to the fully connected layers, there is a lambda layer meaning it does not have trainable weights. This lambda layer includes the transmission power normalization, physical channel, pulse shape, sampling and quantization. The autoencoder takes the coded symbols as blocks with length N and generates where φ 1 is an identity function, because there is a linear activation function for the first hidden layer as can be seen in Table I. Furthermore, Θ 1 and b 1 correspond to the trainable weights (in matrix form) and the biases (in vector form) of the first hidden layer. Both these weights and biases are initialized with Gaussian random variables that have zero-mean, and σ 2 θ and σ 2 b variance, respectively as is standard practice [10], [11]. Notice that where GN is the width of the first hidden layer. The main idea to leverage an autoencoder for a coding scheme is to tackle all kinds of channel and hardware impediments so as to perfectly (or with very small error probability) transfer the coded symbols from a transmitter to a receiver. For this purpose, the autoencoder has to have a large capacity. This is the reason for encoding each coded symbol with G neurons. This obviously decreases the bandwidth efficiency G-fold if conventional orthogonal transmission methods are employed. A better approach is to send the input symbols faster, which is known as non-orthogonal faster-than-Nyquist transmission, at the expense of creating inter-symbol interference (ISI) and colored noise [12]. This method enables us to use a large value for G without any increase in bandwidth at the expense of degrading the minimum distance between the encoded LDPC symbols, since an autoencoder does not have isometry property, i.e., it does not preserve the distances among different inputs. Furthermore, in traditional communication systems faster-than-Nyquist signaling heavily increases the demodulation complexity for a large G. However, this is not an issue when it comes to an autoencoder, because a (neural) decoder with the same complexity is used irrespective of how symbols are transmitted.
The symbols in (4) are transmitted as where ρ is the transmission power, h(t) is the real pulse shape and T is the symbol period for orthogonal transmission. The received continuous time signal over an AWGN channel is filtered with a matched filter h(−t) to yield where z(t) is a zero-mean Gaussian noise with variance σ 2 z and * denotes linear convolution. Writing (6) in integral form gives us Sampling (7) at t = (i − 1)N T + kT G with a sampling period of kT G makes our received symbols Sending symbols faster than the symbol period results in inter-symbol interference and colored noise. To make this clearer, we consider the vector-matrix representation of the received signal which can be expressed as where G ISI is a GN × GN Toeplitz matrix, and its first row becomes [g[0] g[1] · · · g[GN − 1]]. Notice that G ISI would be an identity matrix if orthogonal transmission was used. The correlation of the noise samples is The sampled signal in (8) is quantized before further processing as r ik = Q(y ik ).
In what follows, the decoder part of the autoencoder takes a block of GN samples of The signal in (13) is decoded with the second, third and fourth hidden layers, which have a width of KN and ReLU activation function, and the output layer, which has a width of N and a linear activation function. This gives us the estimate of (2). Mathematically, The parameters Θ 1 , Θ 2 , Θ 3 , Θ 4 , Θ 5 and the biases b 1 , b 2 , b 3 , b 4 , b 5 are denoted as W for brevity. These are optimized according to a squared error loss function as where d i andd i are defined in (2) and (14), respectively. Gathering all these blocks constitutes the estimate of one transmitted codeword aŝ

III. THEORETICAL GUARANTEES
The output of the autoencoder can be written according to its input asd where v i refers to the residual error stemming from the noise and quantization. Since (17) is given to the LDPC decoder, which is optimized according to the data that has Gaussian statistics, it is important to determine the distribution of v i . Next we prove that v i has a Gaussian distribution.
Theorem 1. The autoencoder provides Gaussian distributed data to the LDPC decoder, i.e., v i has a Gaussian distribution when the autoencoder has infinitely large width neural layers and is trained with gradient descent for faster-than-Nyquist transmission and one-bit quantization.
Proof. The autoencoder architecture in Table I can be expressed layer-by-layer as where f (·) corresponds to the lambda layer except quantization and y i is defined in (9). Also, φ 2 (·) = Q(·). Since all the weights and biases are initialized with Gaussian random variables, for each unit (or neuron) in the l th layer z (l) i |x (l−1) is an identical and independent Gaussian random variable with zero mean and covariance except for l = 2. For the second layer z (2) i |x (1) is also a Gaussian random variable due to (10) and Gaussian noise. Specially, z (2) i |x (1) has zero-mean and its covariance is as given by (11).
As the width goes to infinity, (19) can be written in integral form as given in (20). To be more compact, the double integral in (20) can be represented with a function such that Hence, z (6) |z (0) is a Gaussian process with zero mean and covariance z,ẑ))))))) (22) when N → ∞. This means that the output of the autoencoder yields Gaussian distributed data in the initialization phase. During training, the parameters are iteratively updated at time n as where W n = {Θ n 1 , · · · , Θ n 5 , b n 1 , · · · , b n 5 }, and L(·) is the loss function. In parallel, the output z (6) is updated as The gradient term in (24) is a nonlinear function of the parameters. Nevertheless, it was recently proven in [13] that as the width goes to infinity, this nonlinear term can be linearized via a first-order Taylor expansion. More precisely, where the output at the initialization or z (6),0 is Gaussian as discussed above. Since the gradient (and hence the Jacobian matrix) is a linear operator, and a linear operation on a Gaussian process results in a Gaussian process, the output of the autoencoder for a given input (or z (6),n |z (0),n ) is a Gaussian process throughout training with gradient descent. It is worth emphasizing that having a piece-wise quantization function in the second layer does not violate the aproximation in (25), because Q(·) can easily be approximated to a sigmoid function.

IV. SIMULATIONS
We simulate the performance of the proposed coding method by combining the autoencoder with (i) the LDPC code that has a code rate of 1 2 and a codeword length of 648 bits and (ii) the LDPC code that has a code rate of 1 2 and a codeword length of 64800 bits. These LDPC codes have been used in 802.11n and DVB-S2 standards, respectively. Our performance metric is the bit error rate (BER) with respect to the energy per symbol. Throughout the simulation, the symbols are sent 10 times faster than Nyquist rate, which yields a strong ISI.
The 6-layer autoencoder architecture is trained with the squared error function given in (15) with G = 10 and K = 20. This leads to leaving the layer before quantization (or l 1 ) untrained. Using an autoencoder whose input layer is much smaller than the number of coded LDPC symbols per codeword makes training further challenging. To handle these issues, we propose to periodically train the architecture for k codewords and then utilize it for these k codewords. The main reason for this training policy is related with the very poor generalization capability of the neural network due to one-bit quantization.
For the first (shorter codeword) LDPC code, the coded bits are first modulated with 16-QAM and then fed into the autoencoder. These coded symbols are processed by the autoencoder in blocks of 24, i.e., N = 24. As can be observed in Fig. 2(a), using an LDPC code alone is not sufficient for one-bit quantization despite the fact that it decays very rapidly in the case of unquantized samples after 5dB. On the other hand, integrating an autoencoder with this LDPC code brings substantial improvement and leads to obtain a close performance with respect to the unquantized LDPC code. We repeat this experiment for 64-QAM in Fig. 2(b). In comparison to 16-QAM modulation, our coding method that only sees one-bit quantized samples gives nearly the same performance with the LDPC code that processes the unquantized samples. Similar to 16-QAM modulation, this LDPC code alone does not work properly for 64-QAM if there is a one-bit ADC in the receiver.
The performance of the proposed code is also assessed for larger codeword lengths by integrating the autoencoder to the LDPC code that has a codeword length of 64800 bits. All the hyper-parameters of the autoencoder remain the same except that N is taken as 64 instead of 24. This is associated with the fact that large blocks are needed for the autoencoder to capture the structures for large codewords. We observe nearly the same behavior as compared to the shorter LDPC codes as depicted in Fig. 3 for 16-QAM signaling. In this paper, a new design methodology is discussed for developing error correction codes for nonlinear channels by leveraging the merits of deep learning and using the current knowledge in coding theory. This idea is utilized to design a channel code for one-bit quantization. Our results show that the proposed method makes higher-order modulation formats operable for one-bit receivers. This obviously brings in a large spectral efficiency gain. As future work, better autoencoder architectures can be designed instead of using a couple of fully connected layers so as to improve our results. Furthermore, it is interesting to craft novel loss functions for one-bit quantization instead of using the canonical squared loss function, which heavily affects the training policy.