Trainable Projected Gradient Detector for Massive Overloaded MIMO Channels: Data-driven Tuning Approach
Satoshi Takabe Masayuki Imanishi Tadashi Wadayama Ryo Hayakawa Kazunori Hayashi

Date of publication xxxx 00, 0000, date of current version xxxx 00, 0000.
10.1109/ACCESS.2017.DOI





                
  [1]Nagoya Institute of Technology,
		Gokiso, Showa-ku, Nagoya, Aichi 466-8555, Japan

                
  [2]
  		RIKEN Center for Advanced Intelligence Project, Japan
  		Nihonbashi, Chuo-ku, Tokyo 103-0027, Japan
                
  [3]
		Graduate School of Informatics, Kyoto University,
                
                Yoshida-Honmachi, Sakyo-ku, Kyoto 606-8501, Japan

                
  [4]
		Graduate School of Engineering, Osaka City University, 
                Sugimoto, Sumiyoshi-ku, Osaka 558-8585, Japan

                
A part of this work was presented at IEEE ICC 2019 <cit.>.
This work was partly supported by JSPS Grant-in-Aid for Scientific Research (A) Grant Number 17H01280 (TW), 
Grants-in-Aid for Scientific Research (B) Grant Number 16H02878 (TW) and 19H02138 (TW, KH),
 Grant-in-Aid for Young Scientists (Start-up) Grant Number 17H06758 (ST), and 
 Grant-in-Aid for JSPS Research Fellow Grant Number 17J07055 (RH).

 




Corresponding author: Satoshi Takabe (e-mail: s_takabe@nitech.ac.jp).


This paper presents a deep learning-aided iterative detection algorithm for massive overloaded
multiple-input multiple-output (MIMO) systems
 where the number of transmit antennas n is larger than that of receive antennas m.
Since the proposed algorithm is based on the projected gradient descent method with 
trainable parameters, it is named the trainable projected gradient-detector (TPG-detector).
The trainable internal parameters, such as the step-size parameter, 
can be optimized with standard deep learning techniques, i.e.,  
the back propagation and stochastic gradient descent 
algorithms. This approach is referred to as data-driven tuning, and 
ensures fast convergence during parameter estimation in the proposed scheme.
The TPG-detector mainly consists of matrix-vector product operations 
whose computational cost is proportional to m n for each iteration.
In addition, the number of trainable parameters in the TPG-detector is independent of the number of antennas.
These features of the TPG-detector result in a fast and stable training process and reasonable 
scalability for large systems.
Numerical simulations show that the proposed detector achieves a comparable detection performance
to those of existing algorithms for massive overloaded MIMO channels, e.g., the state-of-the-art 
IW-SOAV detector, with a lower computation cost.





massive MIMO, overloaded MIMO, detection algorithm,  deep learning 	



=-15pt
Trainable Projected Gradient Detector for Massive Overloaded MIMO Channels: Data-driven Tuning Approach
    
  Satoshi Takabe12, Member, IEEE,
  Masayuki Imanishi1,
  Tadashi Wadayama1, Member, IEEE,
  Ryo Hayakawa3, Student Member, IEEE,
  and Kazunori Hayashi4, Member, IEEE
    December 30, 2023
============================================================================================================================================================================






§ INTRODUCTION


Multiple-input 
 multiple-output (MIMO) signal processing
 is an indispensable wireless communication technology 
for achieving increased data transfer rates, enhanced reliability, and improved energy efficiency.
In particular, massive MIMO systems have been widely studied because they can provide the high spectral efficiency required for upcoming communication technologies such as the 5th generation (5G) wireless network standard <cit.>.
Since tens or hundreds of antennas are used in a transmitter and receiver,
signal detection for MIMO channels tends to be a computationally intensive task.
It is thus worth studying practical massive MIMO detection algorithms  
which have both low computational complexity and reasonable bit error rate (BER) performance.



In a down-link massive MIMO channel with mobile terminals,
a transmitter in a base station can have many antennas but
a mobile terminal will have far fewer receive antennas
because of restrictions on the cost, space, and power consumption. 
Such a system is known as an overloaded MIMO system, in which 
the number of transmit antennas n is larger than that of receive antennas m.
Overloaded MIMO communications naturally arise in Internet of Things (IoT) wireless networks, 
i.e., data collection by a base station from a large number of sensor nodes
can also be regarded as an up-link overloaded MIMO system
because the number of 
sensor nodes is typically greater than the number of receive antennas at the base station.

A practical detector for massive overloaded MIMO systems should have not only low computational complexity 
but also reasonable BER performance. However, achieving a reasonable balance between the complexity and
detection performance is challenging.
In fact, most naive MIMO detection algorithms have difficulties with either the detection performance or 
the computational complexity.
For example, the zero-forcing detector and minimum mean square error (MMSE) detector <cit.> 
exhibit poor BER performance for overloaded MIMO channels,
while optimal maximum likelihood (ML) detection is computationally intractable.

Among the detection algorithms for overloaded MIMO systems, 
several approximate ML detectors show a reasonable balance between complexity and performance.
Search-based detection algorithms, such as slab-sphere decoding <cit.>
and enhanced reactive tabu search (ERTS) <cit.>, have been proposed for overloaded MIMO channels.
Although these schemes show excellent detection performance, 
they are still computationally expensive for massive MIMO systems.

Some MIMO detection algorithms can be classified 
into the category of convex optimization-based algorithms.
Fadlallah et al. proposed a MIMO detector based on ℓ_1-regularized minimization <cit.>.
Recently, Hayakawa and Hayashi  proposed an iterative detection algorithm with practical computational complexity 
based on  iterative weighted sum-of-absolute value (IW-SOAV) optimization <cit.>.
The IW-SOAV provides a remarkable BER performance in the currently available overloaded MIMO detection algorithms with low computational complexity.

Recently, in the field of sparse signal recovery, 
deep learning techniques have attracted great interest 
because they can significantly improve the signal recovery performances of existing sparse signal recovery algorithms. 
Briefly, by unrolling the signal flow of an 
iterative algorithm, we can obtain a signal-flow graph similar to a feedforward neural network,
where parameters are optimized by back propagation and stochastic gradient 
descent methods.
Gregor and LeCun first proposed such an approach, called the learned iterative shrinkage-thresholding algorithm (LISTA) <cit.>, 
which exhibits a sparse signal recovery performance far superior to that of the original ISTA <cit.>.
Ito, Takabe, and Wadayama proposed the trainable ISTA (TISTA) <cit.> 
which provides significantly faster convergence than ISTA and LISTA. 
Several new algorithms inspired by TISTA have also been developed: 
the TPG decoder for LDPC codes <cit.>,
OAMP-net for MIMO systems <cit.>, DL-OAMP <cit.>, and SURE-TISTA <cit.>.

The emergence of deep learning has also made a great impact on the design of algorithms for wireless communications.
Deep learning-based MIMO detectors, such as the deep MIMO detectors (DMDs) in <cit.>, have been proposed 
 based on the concept of end-to-end modeling of a detector by a neural network <cit.>.
Although these algorithms exhibit a reasonable detection performance, 
they have poor scalability because of the large number of tuning parameters, and their computational cost. 
It thus may be difficult to apply them to massive overloaded MIMO systems. 




The goal of this paper is to propose a novel detection algorithm which is suitable for massive overloaded MIMO systems. Since the proposed algorithm is 
based on the trainable projected gradient (TPG) algorithm, 
it is called the TPG-detector <cit.>.


The TPG-detector consists of two iterative steps: 
the gradient descent step and the soft projection step. 
These two steps include several trainable internal parameters
that can be optimized with standard deep learning techniques, i.e.,  
the back propagation and stochastic gradient descent algorithms.
This approach is referred to as data-driven tuning and
ensures the fast convergence of the parameter estimation in the proposed scheme.



This paper is organized as follows. In Section <ref>, we introduce the concept of data-driven tuning for iterative algorithms
and demonstrate it with a simple example.
In Section <ref>, we describe the problem setting of massive overloaded MIMO systems.
Section <ref> is the main part of this paper, which introduces the proposed TPG-detector for massive overloaded MIMO systems.
In Section <ref>,
the proposed algorithm's detection performance is compared with other algorithms such as the IW-SOAV.
The last section is devoted to a summary of this paper.
Appendix presents a brief review of the IW-SOAV.





§ DATA-DRIVEN TUNING



In this section, we first introduce our key design principle, called data-driven tuning, for numerical optimization algorithms.
A simple example based on a toy problem related to MIMO detection problems 
is then presented to illustrate the basic idea behind data-driven tuning.
In the numerical results, we observe the phenomenon of the data-driven acceleration of convergence for a projected 
gradient descent algorithm. The trainable algorithm shown in the example is then used as the base of the TPG-detector 
proposed in Section <ref>.



 §.§ Basic concept


We here introduce the concept 
of the data-driven tuning of numerical optimization algorithms, whose origin 
dates back to the work by Gregor and LeCun <cit.>.
They unfolded an iterative optimization algorithm and embedded several 
trainable parameters such as matrices in gradient steps
to improve its convergence performance.
In general, by unfolding the iterative processes  (Fig. <ref> (a)) 
and by adding some trainable parameters, we obtain
a  multilayer signal-flow graph that is similar to a deep feedforward neural network (Fig. <ref> (b)).


[!t]()[width=0.95]./signalflow.pdf
(a) A signal-flow diagram of an iterative algorithm, (b) Data-driving tuning based on an unfolded signal-flow graph 
by supervised learning.
 

It is expected that the behavior of each process is controlled by the trainable parameters (black circles in Fig. <ref>(b)).
If each process of the signal-flow graph is differentiable,
these trainable parameters can be adjusted by standard deep learning techniques.
Trainable parameters are tuned by minimizing the loss function 
between the supervised signal and the output 
at the end of the unfolded signal-flow graph. 
It is necessary to prepare sufficient training data to tune trainable parameters.
Fortunately, in problems involving wireless communications,
the training data can be randomly generated according to a 
channel model.

In the training process, a randomly generated input is fed into the signal-flow graph 
and the corresponding supervised signal is also fed to the loss function (Fig. <ref>(b)).
We apply back propagation and 
an SGD type parameter update (SGD, RMSprop, Adam, etc.)
 to optimize the parameters.




 §.§ Example of data-driven tuning

The aim of this subsection is to outline the use of data-driven tuning with a toy problem
similar to the MIMO detection problem.



  §.§.§ Problem setting

Let us consider a simple quadratic optimization problem 

    _x∈{-1, +1}^n1/2Ax - y_2^2,

where  A∈ℝ^n× n is a real-valued matrix and ·_2 represents the Euclidean norm.
We assume that y is randomly generated based on a linear observation 
y = Ax̃ + w∈ℝ^n where
x̃ is a random vector uniformly distributed over {-1, +1}^n and
w∈ℝ^n is an i.i.d. Gaussian random vector with zero mean and variance σ^2.
The optimization problem is regarded as an ML estimation problem for the Gaussian 
linear vector channel, which belongs to NP-hard problems.

In order to approximately solve the problem efficiently, we consider 
a variant of the projected gradient (PG) algorithm.
The PG algorithm considered here is given by 

    r_t    =   s_t + γA^𝖳(y - As_t),
    s_t+1   =   tanh(ξr_t),

where t=1,…, T and tanh(·) is calculated element-wise.
In this paper, H^𝖳 represents the transpose of matrix H.
The initial value is set to s_1=0.

There are two processes in the PG algorithm:
In the gradient descent step (<ref>), 
the vector r_t is updated along with 
the steepest descent direction of the objective function, i.e.,
-∇1/2Ax - y_2^2 = A^𝖳(y - Ax).
The parameter γ corresponds to the step-size parameter which controls the convergence behavior
such as the convergence to a fixed point and the convergence speed.
In the projection step (<ref>), we apply a 
soft projection function tanh(·) to r_t in order to obtain the estimate s_t+1
of the tth iteration. 
The soft projection ensures that the estimate takes a real value close to ± 1.
Although we can use a hard projection function onto the binary symbols {-1, +1} instead of the soft projection,
the PG algorithm fails to converge to a true signal as indicated in Section <ref>.
In this projection step, we have the parameter ξ which adjusts the softness of the soft projection.
 Note that this type of nonlinear projection has been commonly used 
in several iterative multiuser detection algorithms such as the soft parallel interference canceller <cit.>.



  §.§.§ Trainable PG algorithm


As described in the last subsection, the trainable algorithm can be constructed based on the 
PG algorithm by unfolding its iterative processes.
We have the architecture of the trainable PG (TPG) algorithm given by

    r_t    =   s_t + γ_t A^𝖳(y - As_t),
    s_t+1   =   tanh(ξr_t),

with initial condition s_1=0.
In the TPG algorithm, we have
trainable parameters {γ_t }_t=1^T in the gradient descent step[In the implementation, an alternative trainable parameter 
γ̃_t^2 is tuned instead of γ_t to satisfy γ_t=γ̃_t^2≥ 0. This is also true for the TPG-detector in Section <ref>.]. 
Tuning these parameters also adjusts the step-size at each iteration.
In the following discussion, the parameter ξ is treated as a fixed hyperparameter in Section <ref>
 and it is treated as a trainable parameter in Section <ref>.

The trainable parameters are optimized by the standard mini-batch training.
The ith training data point d^i≜ (x^i, y^i) is randomly generated.
The ith input signal x^i ∈{-1, +1 }^n is chosen from the uniform distribution and
the corresponding y^i 
is generated according to y^i = Ax^i + w^i for a given A.
The training dataset of size D,  𝒟≜{d^1, d^2,…, d^D}, 
can be regarded as a mini-batch and is fed into the TPG algorithm simultaneously.
In the following experiment, a matrix A is randomly generated for each mini-batch
to simulate a realistic situation in which a channel matrix changes frequently.
Here, each element of A follows the zero-mean Gaussian distribution with unit variance.

For the tth round of the training process, we feed a mini-batch with D training data points 
to the TPG algorithm to minimize the squared loss function

    L(Θ_t) ≜ D^-1∑_d^i ∈𝒟x^i -  x̂_t(y^i) ^2_2,

where x̂_t(y) ≜s_t+1 is the output of the TPG algorithm after t iterations and Θ_t≜ (γ_1,…,γ_t) 
(or Θ_t≜ (γ_1,…,γ_t, ξ))
 is a vector containing trainable parameters up to the tth iteration.
A back propagation process evaluates the gradient ∇   L(Θ_t), which is 
used for updating trainable parameters
Θ_t as Θ_t:= Θ_t + Δ where Δ is given 
by an SGD type algorithm such as the Adam optimizer <cit.>. 

It should be remarked that a simple single-shot training using t = T
often fails to tune the training parameters accurately because of
 the vanishing gradient phenomenon.
In the TPG algorithm, the phenomenon is caused by
the fact that the derivative of the soft projection function (<ref>) becomes close to zero almost everywhere.
Figure <ref> shows the absolute values of the gradient of the trainable parameters {γ_t}_t=1^T in the TPG algorithm.
We find that the gradient vanishes as the iteration index t becomes small.
The parameter estimators fail to converge in the single-shot training (see Fig. <ref>). 
In order to improve the accuracy of the training process, we use  
the incremental training, which is effective in TISTA <cit.>.
In the incremental training, the parameters {γ_t}_t=1^T are sequentially 
trained from Θ_1 to Θ_T in an incremental manner.

The details of the incremental training are as follows. First, Θ_1 is tuned by minimizing L(Θ_1).
After finishing the training of Θ_1, 
the values of the trainable parameters in Θ_1 are copied to 
the corresponding parameters in Θ_2.
In other words, the results of the training for Θ_1 are carried over to Θ_2 as the initial values.
For each round of the incremental training, which is called a generation, K mini-batches are processed.

[!t]()[width=0.95]./QPbinary_grad_JSAC.pdf
Absolute value of gradient of {γ_t}_t=1^T
 in the TPG algorithm with single-shot training.
 The results obtained after the 10th mini-batch training by the Adam optimizer with learning rate 2.0× 10^-3 are
 n=1000, σ^2=4.0, D=200, and ξ=8.0. 



  §.§.§ Effect of step-size parameter


We show the effects of the data-driven tuning in the TPG algorithm.
Here, we treat the step size {γ_t}_t=1^T as a trainable parameter, while ξ is treated as a hyperparameter.
In the experiment, the dimension of matrix A is set to n=1000 and we set σ^2=4.0.
The number of iterations of the TPG algorithm is T = 20.
We performed two types of training processes for the TPG algorithm to measure the effect of the incremental training.
In the training process with incremental training, we used K=100 mini-batches per generation.
The mini-batch size was set to D=200 and an Adam optimizer learning rate of 2.0× 10^-4 
was used.
In the training process without incremental training (named “TPG-noINC” in Fig. <ref>), 
we used K=2000 and D=200, and the Adam optimizer learning rate was set to 2.0× 10^-3.
The initial values of the trainable parameters were γ_t=1.0× 10^-4 (t=1,…,T).
In this experiment, the softness parameter ξ was set as 8.0 for the TPG algorithm.

Figure <ref> shows the mean squared error (MSE) as a function of the number of iterations 
of the plain PG algorithm when ξ=6.0 and γ=6.5× 10^-4 for
 the TPG algorithms with/without incremental training.
The MSE after t iterations is defined by 10 log_10 (E[||x - x̂_t(y)||_2^2]/n) (dB)
and estimated from 10^4 random samples. 
In the plain PG algorithm, we set
 γ=6.5× 10^-4, which is the optimal value for T=20 (see also Fig. <ref>). 

From Fig. <ref>, 
it is found that the MSE of the TPG algorithm is remarkably lower than that of 
 the plain PG algorithm.
The MSE of the TPG algorithm is below -80 dB at t = 8, while the plain PG yields a smaller MSE after t = 19.
In particular, the TPG algorithm shows a much faster convergence at t=9, indicating that
tuning the trainable parameters leads to fast convergence.
This is an example of the data-driven acceleration of convergence from introducing data-driven tuning. 
Comparing the TPG algorithm with “TPG-noINC” in Fig. <ref> without incremental training, 
we find that one-shot training fails to tune the trainable parameters accurately
as predicted by Fig. <ref>.
This indicates the importance of the incremental training in the data-driven tuning approach.


In Fig. <ref>, we show the relation between the step-size parameter γ 
and the MSE performance of the plain PG algorithm with ξ = 6.0.
It can be observed that the parameter γ must be selected carefully to obtain appropriate convergence.
In other words, the appropriate γ region for fast convergence 
is relatively narrow; specifically, we need to choose an initial estimate within the neighborhood of 6.5 × 10^-4
to achieve -100 dB at T=200. 
This means that optimization of the step size is critical even for the plain PG algorithm.
In addition, the TPG algorithm achieves a lower MSE (around -130 dB), 
which cannot be achieved by the plain PG algorithm with 200 iteration steps. 
This fact implies that embedding a step-size 
parameter into each iteration step provides a substantial improvement in 
the speed of convergence and the accuracy of the solution.

[!t]()[width=0.95]./QPbinary_iter_ICC_ink.pdf
MSE as a function of the number of iterations. The curve (PG) represents 
  the MSE of the plain PG algorithm with γ=6.5× 10^-4 and ξ=6.0.
The curve (TPG) corresponds to the MSE of the TPG algorithm and
the curve (TPG-noINC) corresponds to that of the TPG algorithm without incremental training. 
The parameter ξ is fixed at 8.0 for the TPG algorithm.  


[!t]()[width=0.95]./QPbinary_gamma_ICC_2.pdf
Relationship between the step-size parameter γ and the MSE performance of the plain PG algorithm with ξ=6.0.
  The horizontal solid line represents the MSE of the TPG algorithm with T=20 and ξ=8.0.
  



  §.§.§ Effect of softness parameter

We further discuss the effect of the softness parameter ξ in (<ref>) on the MSE performance.
Figure <ref> shows the MSE curves of the TPG algorithm with different values of 
 ξ and the TPG algorithm with trainable ξ.
The setting of the experiment is the same as above.
As described above, the projection of the TPG algorithm uses the soft projection function
 instead of the hard-projection function corresponding to the ξ→∞ limit.
The results show that a large fixed ξ is not appropriate in terms of the MSE.
On the other hand, the TPG algorithm with small fixed ξ also shows a high MSE.
It is thus crucial to tune not only the step-size parameter {γ_t}_t=1^T but also the softness parameter ξ 
to fully utilize the benefits of the TPG algorithm.
The curve with the label “TPG (ξ trained)” represents the MSE of the TPG with trainable ξ.
In the experiment, we used K=10000 due to the slow convergence of ξ.
In Fig. <ref>, we can see that it outperforms other TPG algorithms with fixed ξ.

[!t]()[width=0.95]./QPbinary_iter_ICC2.pdf
MSE as a function of the number of iterations. The curves represent
  the MSE of the TPG algorithm with different fixed ξ or trainable ξ.
The trained value is ξ≃ 8.560. 



  §.§.§ Discussion

From the experimental results shown above, 
it is found that the TPG algorithm shows remarkable acceleration of the convergence speed, which we call 
data-driven acceleration.
It is emphasized that the optimization problem considered here is randomized because its optimal solution and channel matrix are random variables.
The randomized optimization problem thus has statistical properties in, e.g., gradient information and
landscape of the cost function.
Data-driven acceleration of convergence is a consequence of data-driven tuning
that aims to learn the stochastic variations on the landscape of the objective functions.
During the training process, trainable parameters are tuned to match the typical objective function.

Most of the known acceleration techniques for gradient descent algorithms,
such as the momentum methods,
do not consider the statistical properties of the problems.
On the other hand, data-driven acceleration does learn the statistical nature of the problem.
The internal parameters controlling the behavior of the algorithm 
are adjusted to match the typical objective function via training processes.
Data-driven acceleration is especially advantageous when implemented in 
detection algorithms because it reduces the number of
iterations required without sacrificing the detection performance. This makes the algorithm
faster and more computationally efficient.




§ OVERLOADED MIMO CHANNELS


In this section, we introduce the MIMO channel model used throughout the rest of the paper. 
The numbers of transmit and receive antennas are denoted by n and m, respectively.
Our main interest lies in the overloaded MIMO scenario in which m <n holds.
It is also assumed that the transmitter does not use precoding and that the receiver perfectly knows 
the channel state information, i.e., the channel matrix.

Let x≜ [x_1,x_2,…,x_n]^𝖳∈𝕊 ^n be 
a vector which consists of transmitted symbols x_j (j=1,…,n) from the jth antenna.
The symbol S⊂C represents a signal constellation.
We define 
 y≜ [y_1,y_2,…,y_m]^𝖳∈C^m as a vector with
 received symbols y_i (i=1,…,m) by the ith antenna.
Assuming a flat Rayleigh fading channel, the received symbol vector y is given by

    y = Hx + w,

where w∈C^m consists of zero-mean complex Gaussian random variables 
with covariance matrix σ_w^2 I.
The matrix H=(h_i,j) ∈C^m × n is a channel matrix where h_i,j is
the path gain from the jth transmit antenna to the ith receive antenna.
Each entry of H independently follows a complex circular Gaussian distribution with zero mean and unit variance.
It is convenient to derive an equivalent real-valued channel model 
defined by

    y = Hx + w,

where 

    
    y   ≜[ R̊e̊(y); I̊m̊(y) ]∈R^M, H≜[   R̊e̊(H) - I̊m̊(H);   I̊m̊(H)   R̊e̊(H);           ], 
    x   ≜[ R̊e̊(x); I̊m̊(x) ]∈S^N,  w≜[ R̊e̊(w); I̊m̊(w) ]∈R^M,
 

 and (N,M) ≜ (2n,2m). For z∈ℂ, R̊e̊(z) and I̊m̊(z) 
 represent the real and imaginary part of z, respectively.
The signal set S is the real counterpart of S.
The matrix H∈R^M × N is converted from H.
 Similarly, the noise vector w consists of i.i.d. random variables following a Gaussian distribution
 with zero mean and variance σ^2_w/2.
The signal-to-noise ratio (SNR) per receive antenna is then represented by

    SNR≜E_s/N_0
      =  2n/σ_w^2,

  where E_s≜E[||Hx||^2_2]/m is the signal power per receive antenna and
  N_0 ≜σ_w^2 is the noise power per receive antenna.
Throughout this paper, we assume the QPSK modulation format, i.e., 
S≜{1+j,-1+j,-1-j,1-j}, 
which is equivalent to the BPSK modulation S≜{-1,+1}
in the corresponding real-valued channel model (<ref>).



§ TRAINABLE PROJECTED GRADIENT (TPG)-DETECTOR


The proposed algorithm, called the TPG-detector, is based on the TPG algorithm introduced in Section <ref>.
We first describe the details of the TPG-algorithm and discuss its time complexity.
The key difference between the previously proposed trainable detector <cit.> 
and the TPG-detector described below is the improvement in 
the gradient step which leads to a significant performance improvement when the ratio m/n (<1) is sufficiently large.
The TPG-detector has a lower computational cost than the OAMP-net <cit.>
 and requires a smaller number of trainable parameters
than the DMD <cit.>. These features lead to the low training and execution costs of the TPG-detector.



 §.§ Details of TPG-detector


The ML estimation rule for the MIMO channel is given by

    x̂≜_x∈{-1, +1}^N Hx - y_2^2.

An exhaustive search for the optimal solution is intractable when the system size is large 
because (<ref>) is a non-convex optimization problem.
Similar to Section <ref>, we instead approximate the solution by using the TPG algorithm.
The recursive formula of the TPG-detector is given by

    r_t    =   s_t + γ_t W (y - Hs_t),
    s_t+1   =   tanh(r_t/|θ_t|),

where t ( = 1, …, T) represents the index of an iteration step (or layer) and we use s_1=0 as the initial value.
The estimate of the algorithm after T iterations is given by x̂ = s_T+1.


The processes  (<ref>) and (<ref>) correspond to the gradient descent step and
the soft projection step, respectively, with soft projection function tanh(·).
The matrix W in the gradient step (<ref>) is the linear MMSE (LMMSE)-like
matrix defined by

    W≜H^𝖳 (HH^𝖳 + αI )^-1,

where α∈ℝ is a trainable parameter.
The matrix (<ref>) also appears in the solution of 
the linear regression problem with a quadratic regularization term.
We note that the OAMP-net <cit.> uses LMMSE-like matrices as well. 
The key difference from the TPG-detector 
is that the LMMSE-like matrix needs to be computed at each iteration in the OAMP-net.
In fact, in the tth iteration step of the OAMP-net, 
the matrix is given as W_t by substituting the error variance with α in (<ref>). 

In our previous work <cit.>, 
the Moore-Penrose pseudo-inverse matrix H^𝖳( H H^𝖳)^-1 was applied to the matrix W 
as in the orthogonal approximate message passing (OAMP) algorithm <cit.>
and TISTA <cit.>, 
although a naive gradient descent method for (<ref>) sets H^𝖳 to W as in (<ref>).
However, as we will see in Fig. <ref>, the TPG-detector 
with the Moore-Penrose pseudo-inverse matrix has a poor detection performance 
when the ratio m/n is relatively large.
Here, we instead use the LMMSE-like matrix (<ref>) for  W.

Since it is critical to tune α to obtain a reasonable detection performance, 
the parameter α is also optimized in the training process. 
To reduce the number of trainable parameters and the computational cost, we assume that 
the same value of α is used at each iteration.




 §.§ Trainable parameters


The trainable parameters of the TPG-detector are 2T+1
real scalar variables α, {γ_t}_t=1^T, and {θ_t}_t=1^T.
The parameters {γ_t}_t=1^T in the gradient step
control the step size of the update.
It should be remarked that similar trainable parameters 
are also introduced in the structure of TISTA <cit.>.
The parameters {θ_t}_t=1^T control the softness of the soft projection 
in (<ref>).
Different from the TPG algorithm, the trainable parameters depend on the iteration index t
to increase the degree of freedom of the trainable parameters in the soft projection functions.
The parameter α adjusts the degree of compensation for an ill-conditioned matrix H.
Apart from {γ_t}_t=1^T and  {θ_t}_t=1^T, the TPG-detector uses the same parameter α
for all iterations.


One of the advantages of the TPG-detector is that the number of trainable parameters is small, i.e., O(T), 
and this leads to a fast and stable training process.
The number of trainable parameters in the TPG-detector does not depend on the number of 
antennas n and m
although the DMD <cit.> contains O(n^2T) parameters in T layers.
Since the computational cost for the training process is roughly proportional to the number of 
trainable parameters, the TPG-detector results in a remarkably fast training process, similarly to TISTA <cit.>.




 §.§ Time complexity


The computational complexity of the TPG-detector per iteration 
is O(mn) because calculating the vector-matrix products Hs_t 
and W (y - Hs_t) takes O(mn) computational steps.
We need to calculate the LMMSE-like matrix W with O(m^3) computational steps because the calculation 
involves an matrix inversion. However, the calculation of W is required only when H changes; i.e., the matrix inversion is not needed for each iteration of a TPG-detector if H is constant during the process.
The total computational cost for the TPG-detector (for T iterations) without the initialization process for W
is thus O(mnT).

Another TISTA-based MIMO detection algorithm named OAMP-net <cit.>
also uses the LMMSE matrix as a linear estimator.
However, its computational cost is higher than that of the TPG-detector 
because the OAMP-net needs to compute a matrix inversion at each iteration <cit.>.
The total computational complexity of the OAMP-net with T iteration steps is O(m^3T),
which is larger than that of the TPG-detector.
It should be emphasized that the computational cost affects not only the detection processes
but also to the training processes.





[!t]()[width=0.95]./TI-detector.pdf
The tth layer of the TPG-detector. The trainable parameters are γ_t and θ_t. 



 §.§ Training process
 

The TPG-detector is trained based on the incremental training described in Section <ref>.
The training data are generated randomly according to the channel model (<ref>) 
with fixed variance σ_w^2 corresponding to a given SNR.
As described in Section <ref>, we assume a practical situation in which a channel matrix H is a random variable.
According to this assumption, a matrix H is randomly generated for each mini-batch in the training process 
of the TPG-detector.




§ NUMERICAL RESULTS


In this section, we present the detection performance of the TPG-detector and compare it to that of other
algorithms such as the IW-SOAV, which is known as one of the most efficient iterative algorithms 
for massive overloaded MIMO systems.



 §.§ Experimental setup


In numerical experiments, we uniformly sample a
transmitted vector x
and generate random channel matrices for BER estimation.
The BER is evaluated for a given SNR.

The TPG-detector was implemented with PyTorch 0.4.0 <cit.>.
In this paper, a training process is executed with T=50 rounds using the Adam optimizer <cit.>. 
To calculate the BER of the TPG-detector, a sign function sgn(z) 
which takes a value of -1 if z≤ 0 and 1 otherwise is applied to the output s_T+1
 in an element-wise manner.

For comparison, we use 
the ERTS <cit.>, IW-SOAV <cit.>, and the standard MMSE detector.
The ERTS is a heuristic algorithm based on a tabu search for overloaded MIMO systems.
The parameters of ERTS are based on those given in the original work <cit.>.
The computational complexity for executing the main loop of the ERTS algorithm is O(N_RTSn^2)
where N_RTS is the maximum number of RTSs which is set to 500 in this paper.

The IW-SOAV is a double loop algorithm for massive overloaded MIMO systems (see the Appendix for a brief review).
Its inner loop is the W-SOAV optimization, which recovers a signal using a proximal operator.
Each round of the W-SOAV takes O(mn) computational steps, which is comparable to that of the TPG-detector.
After finishing an execution of the inner loop with K_itr iterations,
several parameters are then updated in a re-weighting process based on a tentative recovered signal.
This procedure is repeated L times in the outer loop.
The total number of steps of the IW-SOAV is thus K_itr L
and the total computational cost is O(K_itr Lmn) without pre-computation.
In the following, we use the simulation results in <cit.> with K_itr=50.
In this case, the computational cost of the TPG-detector is roughly equal to that of the IW-SOAV with L=1
if m/n is a constant.
If L≥ 2, i.e., the outer re-weighting process is executed, 
and the TPG-detector has lower computational complexity than the IW-SOAV. 



 §.§ Main Results




  §.§.§ Selection of matrix W in the gradient step

As described above, we choose the matrix W in the gradient step (<ref>).
The selection of the matrix will affect the detection performance of the algorithms as shown in the OAMP <cit.>.
Before we compare the BER performance of the proposed TPG-detector with other detection algorithms, 
we numerically test the effect of the choice of W.
Figure <ref> shows the detection performance of the TPG-detector with a different choice of W 
when (n,m)=(150,96).
We examined three types of matrices: the matched filter matrix (MF) H^𝖳, 
pseudo-inverse matrix (PINV) H^𝖳( H  H^𝖳)^-1, and LMMSE-like matrix (LMMSE) (<ref>).

From Fig. <ref>, 
we find that the LMMSE-like matrix outperforms other choices of W in a wide range of SNR.


[!t]()[width=0.95]./300_192_matrix.pdf
BER performances for (n,m)=(150,96) for different choices of W; SNR=20 dB.
  The label “MF” stands for the matched filter which corresponds to the gradient of the original problem (<ref>), i.e., W≜H^𝖳, 
“PINV” represents the pseudo-inverse matrix W≜H^𝖳(HH^𝖳)^-1, and 
“LMMSE” is the LMMSE-like matrix (<ref>).
    

[!t]()[width=0.95]./MN.pdf
  BER performances of the TPG-detector with different choices of W as a  function of m/n; n=50, SNR=20 dB, T=50.
  The label “PINV” represents the pseudo-inverse matrix W≜H^𝖳(HH^𝖳)^-1 and 
“LMMSE” is the LMMSE-like matrix (<ref>).  
    


Figure <ref> shows the BER performances of PINV and LMMSE as a function of the ratio m/n when n=50 and SNR=20 dB.
Although the BER performance of LMMSE is close to that of PINV
when m/n≤0.7, LMMSE shows lower BER values when the ratio m/n is close to one.
This is because the random matrix H tends to be ill-conditioned, i.e., 
the condition number of H increases as m/n(<1) increases. 
The LMMSE-like matrix successfully compensates the effect of the condition number.
In fact, as shown in Fig. <ref>, the learned value of α becomes large in the high m/n region.
Otherwise, the learned α is close to zero, which suggests that LMMSE  corresponds to PINV without α.
From these observations, we set the LMMSE-like matrix to W in the proposed TPG-detector
 to treat the ill-conditioned matrix H.  



[!t]()[width=0.95]./alpha.pdf
The learned values of α in the TPG-detector with the LMMSE-like matrix (<ref>);
   n=50, SNR=20 dB, T=50. 
    



  §.§.§ Signal detection process


[!t]()[width=0.95]./signal_detect
  Output s_t+1 of the TPG-detector (orange symbols) after (a) t=1, (b) t=5, (c) t=10 iterations; (n,m)=(25,16), SNR=20 dB, T=10.  Blue symbols represent the true signals for comparison.
  


We next demonstrate the detection process of the TPG-detector.
Figure <ref> shows the output s_t+1 of the TPG-detector (T=10) after t = 1, 5, and 10 iterations. 
The system size is (n,m)=(25,16) and the SNR is set to 20 dB.
For comparison, the true signal is also shown in the figure.
We find that the TPG-detector (t=1) mistakenly detects a few elements 
of the input signal as shown in Fig. <ref> (a).
After the 5th iteration, as shown in Fig. <ref> (b), no bit errors occur while
some values of s_6 are not ± 1 because of the soft projection in (<ref>).
However, after some additional iterations, all elements of the output are sufficiently close to ±1 (see  Fig. <ref> (c)) 
indicating that the MSE loss (<ref>) is decreasing.  










  §.§.§ BER performances


[!t]()[width=0.95]./100_64_SNR.pdf
  BER performances for (n, m) = (50,32).
    
  
[!t]()[width=0.95]./200_128_SNR.pdf
  BER performances for (n, m) = (100,64).
    
  
[!t]()[width=0.95]./300_192_SNR.pdf
  BER performances for (n, m) = (150, 96).     

We present the BER performance of each detector as a function of SNR for (n,m)=(50,32), (100,64), and (150,96)
in Figs. <ref>-<ref>, respectively.
All the results show that the MMSE detector fails to detect transmitted signals reliably (BER ≃ 10^-1) 
because the system is underdetermined.

For (n,m)=(50,32) in Fig. <ref>, ERTS outperforms the other detection algorithms by a large margin when SNR is larger than 10 dB.
It should be remarked that ERTS has a much greater time complexity (around several orders of magnitude) than that of the IW-SOAV (see Fig. 7 in <cit.>).
Comparing the TPG-detector with the IW-SOAV, we find that the TPG-detector performs far better than the IW-SOAV (L=1) and
shows a BER performance close to the IW-SOAV (L=5) when SNR is below 20 dB.
Note that the computational cost for executing the TPG-detector with T=50 is close 
to that of the IW-SOAV (L=1). The IW-SOAV (L=5) requires K_itrL=250 iterations, which is 5 times as many as 
the number of iterations required for the TPG-detector with T = 50.
This implies that the TPG-detector can achieve a good detection performance with a relatively low computational cost.


For (n,m)=(100,64) in Fig. <ref>, 
ERTS detector shows the best BER performance in a middle SNR region 
where SNR is between 10 and 18 dB but the BER curve of ERTS is saturated after 20 dB.
The TPG-detector and the IW-SOAV (L = 1 and L=5) outperform ERTS in a high SNR regime.
In such a regime, the TPG-detector exhibits a BER performance superior to that of the IW-SOAV (L=1) for the entire range of SNR,
i.e., the TPG-detector achieves an approximately 5 dB gain at BER=10^-4 over the IW-SOAV (L=1).
More interestingly, the BER performance of the TPG-detector  
is fairly close to that of the IW-SOAV (L =5) when the SNR is below 20 dB.
When SNR=20 dB, the BER estimate of the TPG-detector  
is 1.0 × 10^-4 whereas that of the IW-SOAV (L=5)
is 2.1 × 10^-5.

Figure <ref> shows the BER performance for (n,m)=(150,96).
In this case, ERTS shows a poor BER performance, and cannot achieve a BER smaller than 10^-3 for any SNR. 
The TPG-detector successfully recovers transmitted signals with lower BER than that of the IW-SOAV (L=1).
It again achieves about a 5 dB gain against the IW-SOAV (L=1) at BER=10^-5.
In addition, the TPG-detector achieves the lowest BER when SNR=12.5 dB.
Although the IW-SOAV (L = 5) shows a considerable performance improvement when SNR>15 dB,
the gap between the curves of the TPG-detector and the IW-SOAV (L=5)  is only  2 dB at BER=10^-5.



  §.§.§ System-size dependency

In Fig. <ref>, we show the BER performances of the TPG-detector and IW-SOAV (L=1) as a function of
 the number of antennas n with the rate m/n=0.6 fixed.
The gap in their BER performances is especially large for SNR=20 dB.
We also find that the gain of the TPG-detector increases as n grows despite these algorithms having the same computational costs.
It is confirmed that the TPG-detector outperforms low-complexity algorithms especially in the massive overloaded MIMO channels.

[!t]()[width=0.95]./N_depend_JSAC_revise.pdf
  BER performances as functions of the number of antennas n for fixed rate m/n=0.6 with SNR=15,20,30 dB.
  




  §.§.§ Trained parameters


Figure <ref> displays the learned parameters {γ_t}_t=1^T and {|θ_t|}_t=1^T of the TPG-detector   
after training as a function of the iteration index t(=1,…,T).
We find that they exhibit a zigzag shape with a damping amplitude similar to that observed in TISTA <cit.>.
The parameter γ_t, the step size of the linear estimator, is expected to accelerate the convergence of the signal recovery.
Theoretical treatments for providing a reasonable interpretation of 
the characteristic shapes of the learned parameters 
are left as future work.


The trained values of α for different SNR values are shown in Fig. <ref>.
We find that the parameter α depends on the value of SNR.
In particular, the trained value decreases when SNR≤7.5 dB.
This tendency is similar to that of another parameter related to α in the IW-SOAV <cit.> using the LMMSE-like matrix.
On the other hand, the trained value is non-monotonic unlike the IW-SOAV; specifically, it increases when SNR<7.5 dB.
The parameter corresponding to α in the IW-SOAV should be chosen in advance by numerical simulations.
The learning process in the TPG-detector easily tunes the parameter α in addition to other trainable parameters.

[!t]()[width=0.95]./Parameter_N300_SNR20.pdf
Sequences of learned parameters γ_t (top) and |θ_t| (bottom); 
  (n,m)=(150,96), SNR=20 dB, 1≤ t≤ T=50. The trained value of α is 34.68.  

[!t]()[width=0.95]./alpha_N300.pdf
  The trained α values for different SNR values; (n,m)=(150,96) and T=50.  



  §.§.§ Computation time


We finally discuss the scalability of the TPG-detector to show the required computation time for training.
The empirical execution time of the training process of the TPG-detector is measured
 by using a PC with GPU NVIDIA GeForce GTX 1080 and Intel Core i7-6700K CPU 4.0 GHz with 8 cores.
Table <ref> presents the execution time of the training processes with different n.
Even for the case (n, m) = (150, 96), we need only 20 minutes for training the TPG-detector and
 this result indicates that the training process of the TPG-detector is practical for fairly large systems.








§ CONCLUSION


In this paper, we proposed the TPG-detector, a deep learning-aided iterative decoder for massive overloaded MIMO channels.
It is based on the concept of data-driven tuning using standard deep-learning techniques.
The TPG-detector contains two trainable parameters for each layer: γ_t controlling the size of the gradient descent step and
 θ_t controlling the softness of the soft projection. In addition, the parameter α in the LMMSE-like matrix W (<ref>) is also optimized in the training process.
The total number of trainable parameters in T layers 
is thus 2T + 1, which is significantly smaller than used 
in previous studies, such as for the DMD <cit.>.
This promotes fast and stable training for the TPG-detector.

The computational complexity of the TPG-detector with T iteration steps without the initialization on 
W is O(mnT). This is an advantage over the OAMP-net <cit.> which
needs a matrix inversion for each iteration and has a time complexity of O(m^3T).
This indicates that the TPG-detector is more scalable for massive MIMO systems in terms of the computational cost.

Numerical simulations show that the use of the LMMSE-like matrix successfully 
improves the BER performance of the TPG-detector even when the ratio m/n is relatively large, i.e., 
the channel matrix is ill-conditioned.
It is also revealed
that the proposed TPG-detector outperforms the state-of-the-art IW-SOAV (L=1) by a large margin and
achieves a comparable detection performance to the IW-SOAV (L=5).
The TPG-detector therefore can be seen as a promising iterative detector for massive overloaded MIMO channels 
providing an excellent balance between a low computational cost and a reasonable detection performance.


In this paper, we treat MIMO systems 
with QPSK modulation by separating the real and imaginary part of the signals.
It is expected that the extension of the TPG-detector to 16QAM or 64QAM modulations is straightforward by using corresponding MMSE functions as a soft projection function
  (see <cit.> for details), which is left for a future work here.
In contrast, this approach will fail for 2^K-PSK  (K>2) modulations
because it neglects correlations in the modulation format.
Instead, it is crucial to treat complex-valued signals directly as shown in some recent studies <cit.>.
As a trainable algorithm based on data-driven tuning, some of the authors recently proposed the 
complex-field TISTA for linear and nonlinear inverse problems in the complex domain <cit.>.
Applying this approach to a massive overloaded MIMO system is a future research task.   




§ BRIEF REVIEW OF IW-SOAV

Here, we give a brief review of the IW-SOAV detector.
The IW-SOAV is an effective iterative detection algorithm 
for massive overloaded MIMO systems proposed in <cit.>.
It is based on a variant of the Douglas-Rachford algorithm <cit.> which solves the following weighted SOAV (W-SOAV) optimization problem:

    ŝ≜argmin_z∈ℝ^2n   ( ∑_j=1^2nw_j^+|z_j-1|+∑_j=1^2nw_j^-|z_j+1|. 
       .
    + α/2y-Hz_2^2),

where z_j (j=1,…,2n) is the jth element of z and α(>0) is a constant.
Here, we assume that each symbol x_j in the transmitted signal x 
is an independent random variable which takes a value of 1 w.p. w_j^+ and -1 w.p. w_j^-≜ 1-w_j^+.

The IW-SOAV repeats the following procedures: (i) estimation of w_j^+ based on the detected signal and
 (ii) detection of the transmitted signal by solving the W-SOAV optimization (<ref>).
The IW-SOAV is thus a double-loop algorithm.

In the outer loop corresponding to procedure (i), the algorithm approximates {w_j^+} for each transmitted symbol.
The estimation is based on the approximate log likelihood ratio which is given by

    Λ̂_j=∑_i=1^2m2h_i,j{y_i-(μ̂_i-h_i,jŝ'_j)}/σ̂_i^2-h_i,j^2(1-ŝ_j^' 2) ,

where h_i,j is the (i,j)th element of matrix H and ŝ' represents a clipped signal of ŝ; specifically i.e.,
ŝ'_j (j=1,…,2n) takes a value of -1 if ŝ_j<-1, and 1 if ŝ_j>1, and s_j otherwise.
In addition, we define 

    μ̂_i    ≜∑_k=1^2n h_i,kŝ'_k,
    σ̂_i^2    ≜∑_k=1^2n h_i,k^2 (1-ŝ_k^' 2) +σ_w^2/2
    ,

for i=1,…, 2m.
Then, the weight w_j^+ is calculated by

    w_j^+ =e^Λ̂_j/1+e^Λ̂_j.



In the inner loop corresponding to procedure (ii), 
the algorithm solves the W-SOAV optimization problem with an iterative process defined by the following
recursive formula:

    z_t    = (I+αγH^𝖳H)^-1(r_t+αγH^𝖳y)
    r_t+1   = r_t + θ_t (ϕ_γ(2z_t-r_t)-z_t),
 
where t(=1,…,K_itr) denotes the iteration step, 
θ_t∈ [ϵ,2-ϵ] is a constant, and 
ϕ_γ:ℝ^N→ℝ^N is a component-wise function 
whose jth element [ϕ_γ(z)]_j is defined by

    [ϕ_γ(z)]_j ≜
    z_j + γ    (z_j<-1-γ)
    
    -1     (-1-γ≤ z_j<-1-d_jγ)
    
    z_j + d_jγ    (-1-d_jγ≤ z_j<1-d_jγ)
    
    1     (1-d_jγ≤ z_j<1+γ)
    
    z_j - γ    (1+γ≤ z_j)
    
    ,

with d_j≜ w_j^+-w_j^-.
The choice of the parameters γ>0, ϵ∈(0,1), and the initial value r_0∈ℝ^2n are arbitrary.
In this W-SOAV optimizer, the transmitted symbol is received as x̂=z_K_itr+1 
after K_itr iteration steps.
The IW-SOAV starts with ŝ=0 and repeats L outer loops with K_itr inner loops.
When all loops are finished, the sign function sgn(·) is applied to the output x̂ in an element-wise manner.
The parameter α is fixed appropriately depending on SNR.
In numerical experiments in Section <ref>, we used r_0=0, ϵ=0, γ =1, and θ_t=1.9 (t=1,…,K_itr),
and set α as in <cit.>.

The computational cost of each iteration of the IW-SOAV is O(mn).
Although it contains a matrix inversion operation which takes O(n^3) computational steps, the inversion can be computed in advance.
Since the total number of inner and outer loops is K_itrL,
the computational cost of the IW-SOAV without pre-computation is O(K_itrLmn).
















99
MUMIMO E. G. Larsson, O. Edfors, F. Tufvesson, and T. L. Marzetta, “Massive MIMO for next generation wireless systems,” IEEE Comm. Magazine, vol. 52, no. 2, pp. 186-195, Feb. 2014.

Yang S. Yang and L. Hanzo, “Fifty years of MIMO detection: the road to large-scale MIMOs,” 
IEEE Comm. Surveys and Tutorials, vol. 17, no. 4, pp. 1941-1988, Fourthquarter 2015.

Shnidman D. A. Shnidman, “A generalized Nyquist criterion and an optimum linear receiver for a pulse modulation system,” The Bell System Technical Journal, vol. 46, no. 9, pp. 2163-2177, Nov. 1967.



SSD K. K. Wong, A. Paulraj, and R. D. Murch, “Efficient high-performance decoding for overloaded MIMO antenna systems,”  IEEE Trans. Wireless Commun., vol. 6, no. 5, pp. 1833-1843, May 2007.
ERTS T. Datta, N. Srinidhi, A. Chockalingam, and B. S. Rajan, “Low-complexity near-optimal signal detection in underdetermined large-MIMO systems,” in Proc. National Conf. Comm., Feb. 2012, pp. 1-5.
Fad1 Y. Fadlallah, A. Aïssa-El-Bey, K. Amis, D. Pastor, and R. Pyndiah, “New decoding strategy for underdetermined MIMO transmission using sparse decomposition,” in Proc. in Proc. 2013 21st Eur. Signal Proc. Conf., Sep. 2013, pp. 1-5.

IW-SOAV1 R. Hayakawa, K. Hayashi, H. Sasahara, and M. Nagahara, “Massive overloaded MIMO signal detection via convex optimization with proximal splitting,”
in Proc.  2016 24th Eur. Signal Proc. Conf.,  Aug./Sep. 2016, pp. 1383-1387.
IW-SOAV2 R. Hayakawa and K. Hayashi, “Convex optimization-based signal detection for massive overloaded MIMO systems,” in IEEE Trans. Wireless Comm., vol. 16, no. 11, pp. 7080-7091, Nov. 2017.





LISTA K. Gregor and Y. LeCun,
“Learning fast approximations of sparse coding,”
in Proc. 27th Int. Conf. Machine Learning, pp. 399–406, 2010.

ISTA2 I. Daubechies, M. Defrise, and C. De Mol,
“An iterative thresholding algorithm for linear inverse problems with a sparsity constraint,”
Comm. Pure and Appl. Math., vol. 57, no. 11, pp. 1413-1457, Aug. 2004.

TISTA D. Ito, S. Takabe, and T. Wadayama, “Trainable ISTA for sparse signal recovery,”
IEEE Int. Conf. Comm., Workshop on Promises and Challenges of Machine Learning in Communication Networks, Kansas city, May. 2018. 

TISTA2 D. Ito, S. Takabe, and T. Wadayama, “Trainable ISTA for sparse signal recovery,”
IEEE Trans. Sig. Process., vol. 67, no. 12, pp. 3113-3125, Jun., 2019.





LP T. Wadayama and S. Takabe, “Deep Learning-Aided Trainable Projected Gradient Decoding for LDPC Codes,”
accepted to 2019 IEEE Int. Symp. Info. Theory (ISIT); arXiv:1901.04630.
OAMP-net H. He, C.-K. Wen, S. Jin, and G. Y. Li,
“A model-driven deep learning network for MIMO detection,” arXiv:1809.09336, 2018.
CP1 J. Zhang, H. He, C.-K. Wen, S. Jin and G. Y. Li, “Deep Learning Based on Orthogonal Approximate Message Passing for CP-Free OFDM,” 2019 IEEE Int. Conf. Acoustics, Speech and Signal Process. (ICASSP), Brighton, United Kingdom, 2019, pp. 8414-8418.

CP2 J. Zhang, C.-K. Wen, S. Jin, and G. Y. Li, “Artificial Intelligence-aided Receiver for A CP-Free OFDM System: Design, Simulation, and Experimental Test,” arXiv preprint arXiv:1903.04766 (2019).
SURE M. Yao, J. Dang, Z. Zhang, and L. Wu, “SURE-TISTA: A Signal Recovery Network for Compressed Sensing,"
2019 IEEE Int. Conf. Acoustics, Speech and Signal Process. (ICASSP),, Brighton, United Kingdom, 2019, pp. 3832-3836.

DMD1 N. Samuel, T. Diskin, and A. Wiesel, “Deep MIMO detection,” 
2017 IEEE 18th Int. Workshop Signal Processing Advances in Wireless Comm., Jul. 2017, pp. 1-5.
DMD2 N. Samuel, T. Diskin, and A. Wiesel, “Learning to detect,” IEEE Trans. Signal Process., vol. 67, no. 10, pp. 2554-2564, May. 2019.

Oshea T. J. O'Shea, T. Erpek, and T. C. Clancy, “Deep learning based MIMO communications," arXiv preprint arXiv:1707.07980, 2017.
Wang T. Wang, C. Wen, H. Wang, F. Gao, T. Jiang and S. Jin, “Deep learning for wireless physical layer: Opportunities and challenges,” China Comm., vol. 14, no. 11, pp. 92-111, Nov. 2017.
Wen C. Wen, W. Shih and S. Jin, “Deep Learning for Massive MIMO CSI Feedback,” IEEE Wireless Comm. Lett., vol. 7, no. 5, pp. 748-751, Oct. 2018.



TPG S. Takabe , M. Imanishi, T. Wadayama, and K. Hayashi, “Deep Learning-Aided Projected Gradient Detector for Massive Overloaded MIMO Channels,”  accepted to IEEE International Conference on Communications (ICC2019), 2019; https://arxiv.org/abs/1806.10827.

PIC D. Divsalar, M. K. Simon, and D. Raphaeli, 
“Improved parallel interference cancellation for CDMA”, IEEE Trans. Commun., vol. 46, no. 2, pp. 258-268, Feb. 1998.

Adam D. P. Kingma and  J. L. Ba, “Adam: A method for stochastic optimization,” arXiv:1412.6980, 2014.

OAMP J. Ma and L. Ping,
“Orthogonal AMP,”
IEEE Access, vol. 5, pp. 2020-2033, Jan. 2017.

PyTorch
PyTorch, <https://pytorch.org>.





Jeon C. Jeon, R. Ghods, A. Maleki, and C. Studer, “Optimality of large MIMO detection via approximate message passing," 2015 IEEE International Symposium on Information Theory (ISIT), Hong Kong, 2015, pp. 1227-1231.

HAYA1 R. Hayakawa and K. Hayashi, “Reconstruction of complex discrete-valued vector via convex optimization with sparse regularizers," IEEE Access, vol. 6, pp. 66499-66512, Oct. 2018.


CTISTA S. Takabe and T. Wadayama, “Complex field-trainable ISTA for linear and nonlinear inverse problems,” arXiv:1904.07409, 2019.

RD P. Combettes and J.-C. Pesquet, “Proximal splitting methods in signal processing,” 
in Fixed-Point Algorithms for Inverse Problems in Science and Engineering 
(Springer Optimization and Its Applications), vol. 49. New York, NY, USA: Springer, 2011, pp. 185-212.








