{'fraction_non_alphanumeric': 0.043635754517473146, 'fraction_numerical': 0.01398689252287527, 'mean_word_length': 4.4414948159963545, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 9, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 8, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Binary MIMO Detection via Homotopy Optimization and Its Deep Adaptation

In this paper we consider maximum-likelihood (ML) MIMO detection under one-bit quantized observations and binary symbol constellations. This problem is motivated by the recent interest in adopting coarse quantization in massive MIMO systems--as an effective way to scale down the hardware complexity and energy consumption. Classical MIMO detection techniques consider unquantized observations, and many of them are not applicable to the one-bit MIMO case. We develop a new non-convex optimization algorithm for the one-bit ML MIMO detection problem, using a strategy called homotopy optimization. The idea is to transform the ML problem into a sequence of approximate problems, from easy (convex) to hard (close to ML), and with each problem being a gradual modification of its previous. Then, our attempt is to iteratively trace the solution path of these approximate problems. This homotopy algorithm is well suited to the application of deep unfolding, a recently popular approach for turning certain model-based algorithms into data-driven, and performance enhanced, ones. While our initial focus is on one-bit MIMO detection, the proposed technique also applies naturally to the classical unquantized MIMO detection. We performed extensive simulations and show that the proposed homotopy algorithms, both non-deep and deep, have satisfactory bit-error probability performance compared to many state-of-the-art algorithms. Also, the deep homotopy algorithm has attractively low computational complexity.


Introduction
MIMO detection has been, for decades, at the center of some very important developments in signal processing, communications and beyond. Its problem statement is simple-to detect a multitude of finite-alphabet variables from a noisy observation of their linearly entangled counterparts. The problem is, however, very challenging if the goal is to build an MIMO detection algorithm that can achieve optimal or near-optimal detection performance with a low implementation cost, particularly, for large problem sizes. The above goal has attracted generations of researchers' innovations, e.g., around the 1990's for multiuser code division multiple access, around the 2000's for multi-antenna systems, and recently for massive antenna arrays; and the consequence is a rich, enduring, collection of methods-such as sphere decoding methods [1,2] for implementing the optimal maximum-likelihood (ML) detection via combinatorial search; convex relaxation methods [3][4][5][6] for efficient ML approximation via convex optimization; lattice reduction-aided methods [7] for improving the channel conditioning, and thereby performance, via basis design under integer coefficient constraints; soft detection methods [8,9] for posterior inference of the unknown finite-alphabet variables via various approximations; to name a few. These developments show intimate connections with studies in other areas, such as complexity theory, combinatorial and continuous optimization, statistical inference, etc. Also, recent research takes insight from approximate message passing in compressive sensing [10] to tackle MIMO detection [11]. Hence, MIMO detection is a topic of farreaching implications. We refer the reader to the literature, e.g., [12], for a chronological account of the MIMO detection developments and a coverage of the numerous algorithms therein.
Lately, MIMO detection has been igniting new interest in two recent research directions, namely, coarsely quantized massive MIMO and deep learning for communications. We separately describe them in the following two subsections.

Coarsely Quantized Massive MIMO Detection
As a serious impediment to the real-world massive MIMO implementation, it is well-known that if every radio-frequency front end of a massive MIMO system is equipped with a high-resolution analog-to-digital converter (ADC) or digital-to-analog converter (DAC)-as in conventional MIMO, the system will be very expensive to implement in terms of hardware complexity and energy consumption. In view of this, there has been movement toward the use of low-resolution ADCs or DACs in massive MIMO. One arising problem in this context is MIMO detection under coarsely quantized observations-particularly one-bit, or sign-only, observations.
A challenge with coarsely quantized MIMO detection is that the classical MIMO detection methods we have studied for decades cannot be straightforwardly extended to the quantized case; this is owing to the different likelihood function in the quantized case. Some powerful classical methods, such as sphere decoding, semidefinite relaxation [5,6] and lattice reduction, are inapplicable in the quantized case because they were designed to exploit the convex quadratic structure of the ML objective function in the unquantized case. Some researchers study the impacts of coarse quantizations on some classical MIMO detection methods (e.g., zero forcing) [13], while others redesign the MIMO detection methods to better harness the problem structure. For the latter, Studer and Durisi took inspiration from the classical linear minimum-mean-square-error (MMSE) detection to derive a variant in the quantized case [14]; Choi, Mo and Heath developed a convex sphere relaxation of one-bit ML MIMO detection [15]; Jeon et al. devised a sphere decoder for onebit ML MIMO detection [16] (its appearance is very different from those we see in classical MIMO detection); approximate message passing was redesigned for quantized MIMO detection in [17,18].

Deep Learning for MIMO Detection
Recently, the tremendous successes of deep neural networks in natural language processing, computer vision and machine learning have sparked widespread interest in the communications community. In particular, we have seen a variety of emerging deep network applications for communications, such as end-to-end communication system design [19], multiuser power control [20], and, as our main interest, MIMO detection [21][22][23][24][25][26][27]. Neural networks for MIMO detection was already considered in around the 1990's [28,29]; it is worth noting that the motivation at the time lies in neural networks' ability to generate nonlinear decision regions, which the then-popular methods of linear and decision-feedback detection have limitations. In the recent renewed interest, we have so far not seen a report on successfully training a deep neural network-specifically, that under a standard network architecture-that gives consistently near-optimal detection performance and good training stability for a broad range of MIMO settings. Instead, attention appears to have been drawn to the design approach of deep unfolding, which has a flavor of leveraging on both the existing model-based MIMO detection methods and the data-driven deep learning approach.
Deep unfolding was first introduced in the context of sparse coding by Gregor and LeCun [30], and it has recently received much attention [31,32]. The rationale is to see an existing iterative algorithm, e.g., the iterative shrinkage thresholding algorithm (ISTA) in sparse coding (see [30]), as a deep network. It intends to learn a better algorithm than its predecessor algorithm by untying some parameters of the predecessor, and then by learning those parameters from data. Also, one can modify part of the structure of the predecessor to make it more general, and learn the new structure from data. The result is a structured deep network whose structures preserve some of the structures prescribed under a model-based framework. In the work by Gregor and LeCun, they showed that the learnt ISTA requires much less number of iterations, or layers, to achieve performance comparable to ISTA.
Deep unfolding was first applied to MIMO detection by Samuel, Diskin and Wiesel in 2017 [21]. The algorithm there, called DetNet, is a deep unfolding of a non-convex projected gradient algorithm for ML MIMO detection. We have seen growing interest with deep learning for MIMO detection since the DetNet work. For example, the works [23,24] studied deep network structures similar to DetNet. The works [25,26] studied the deep unfolding of approximate message passing. Apart from deep unfolding, the work [27] applied deep learning to learn the sphere radius in sphere decoding.

Present Contribution and Related Works
The present contribution considers one-bit ML MIMO detection under binary symbol constellations. We tackle the problem by a non-convex optimization strategy, namely, homotopy optimization; see [33][34][35][36][37][38] and the references therein. Also called continuation or graduated non-convexity, homotopy optimization is an idea that arose independently from a variety of applications in different fields, such as molecular conformation [33], sparse optimization [35] and neural network training [37]. Homotopy methods can be vastly different from one application to another, but they often follow a common principle. Specifically, it entails a problem transformation-called homotopy map-that has the flexibility of either making the transformed problem easier to solve (e.g., convex) but less accurate in approximating the original problem; or making the transformed problem harder but closer to the original. Then, the attempt is to iteratively trace the solution path of a sequence of such approximate problems, from easy to hard and in a gradual fashion. In the context of MIMO detection, our empirical experience is the following: tackling the ML MIMO detection problem directly by a straight application of a non-convex algorithm may result in poor detection performance, owing to convergence to poor local minima; but handling the problem indirectly via the aforementioned gradually easy-to-hard optimization principle may lead to better performance.
Homotopy optimization offers us a principle, not a numerical algorithm that fits all problems. We often need to find a suitable problem transformation for the application at hand. We employ the non-convex continuous reformulation of binary optimization in [39], as well as the efficient first-order algorithm design therein. This technique was previously proposed by us to tackle a one-bit MIMO precoding problem. In the present contribution, we incorporate this technique into the theme of homotopy optimization and explore its potential in MIMO detection. Also we enrich the result by connecting homotopy optimization with Lagrangian dual relaxation (LDR), as will be shown in Section 3.2. It is worth noting that the LDR notion plays a vital role in ML MIMO detection; e.g., semidefinite relaxation and regularized lattice decoding can be interpreted as outcomes of LDR [40,41].
In our development, we found that the homotopy algorithm has a structure favorable for deep unfolding. This motivates to consider deep unfolding of our homotopy algorithm. Our deep unfolding involves mild untying and structure modification, which means that the structure does not change a lot. By empirical experience, our deep homotopy network is easy to train. Also our deep homotopy network is trained to cater for different channels, rather than a fixed channel. Note that the former is more preferable since it allows us to have the expensive training done offline; the latter requires online training for every given channel, and the subsequent real-time computational overheads may be significant.
The contributions of this work are summarized as follows.
1. As a new attempt to tackle the challenge of efficient high-performance MIMO detection, we propose a non-convex homotopy optimization method for one-bit ML MIMO detection under binary symbol constellations. By extensive simulations, we show that the homotopy algorithm yields considerably better detection performance (specifically, bit-error rate performance) than some state-of-the-art algorithms. However it has a relatively high complexity requirement, compared to the state-of-the-art.
2. We apply deep unfolding to the proposed homotopy algorithm to learn a better algorithm.
Simulation results show that the deep-unfolded homotopy algorithm has detection performance comparable to the original homotopy algorithm, and it does so with a much lower complexity requirement-20 layers, or iterations, in all of our tested MIMO settings. The deep-unfolded homotopy algorithm also runs faster than the state-of-the-art algorithms.
3. While our initial focus is on one-bit MIMO detection, the proposed homotopy method is also applicable to classical (unquantized) MIMO detection. Simulation results show that the homotopy algorithms (deep and non-deep) provide near-optimal detection performance, and the other empirical observations are similar to those in the one-bit case.
We should discuss related works. In the decades of MIMO detection research, non-convex optimization was considered; see, e.g., [42,43]. But the notion of homotopy optimization for attempting to avoid poor local minima, as well as our non-convex continuous reformulation for binary optimization, appear to have not been previously applied to MIMO detection. Also, our homotopy method for binary optimization appears to have not been seen in the prior homotopy optimization literature. Furthermore, the majority of the current deep MIMO detection studies consider the classical case. Our deep unfolding design covers both the classical and one-bit MIMO cases.
We may release the source code at a later stage for reproducible research.
2 Problem Statement

Model and ML Detection
Let us begin by posing our problem in its generic abstract form. Consider a data model where y ∈ {−1, 1} M is an observed data vector; x ∈ {−1, 1} N is a binary vector; sgn denotes the element-wise sign function; H ∈ R M ×N is a system matrix; v ∈ R M is element-wise independent and identically distributed (i.i.d.) Gaussian noise, with mean zero and variance σ 2 . Our task is to detect x from y, given that H and σ are known. We do so by pursuing the maximum-likelihood (ML) detection approach-which guarantees the minimum error probability of detecting x under the assumption of element-wise uniform i.i.d.
x. Under the model (1), the ML detector takes the formx where 2π e −τ 2 /2 dτ , and h i denotes the ith row of H; see [15,44]. The ML problem (2) is a discrete optimization problem, and a method capable of findingx ML tractably-given any instance (y, H, σ)-appears to be unavailable. In fact, it is computationally challenging to solve problem (2) exactly when the problem dimension N is large; e.g., complete enumeration of all points in {−1, 1} N is impossible for large N . Our problem is to find an efficient strategy to tackle problem (2).
The above problem arises in one-bit massive MIMO detection which has spurred great interest recently. To describe it, consider an uplink multiuser MIMO scenario where multiple single-antenna users simultaneously transmit information symbols to a massive MIMO base station (BS); and, to reduce the hardware cost, the BS employs low-resolution ADCs. Assuming flat fading channels, the signal model of the above scenario can be formulated as where y C ∈ C M C is a receive vector whose ith element y C,i represents the complex baseband received signal at the ith antenna of the BS; x C ∈ X N C C is a transmit vector whose ith element x C,i is the symbol transmitted by the ith user; M C and N C are the numbers of receive antennas and users, respectively; X C ⊂ C is the symbol constellation set; H C ∈ C M C ×N C is the MIMO channel; Q denotes an element-wise quantization function; v C ∈ C M C is element-wise i.i.d. circular Gaussian noise with mean zero and variance σ 2 C . Let us consider the case of one-bit quantization Q(y C ) = sgn(R{y C }) + j · sgn(I{y C }) and quaternary phase shift keying (QPSK) constellation X C = {±1 ± j}. The complex-valued model (3) can be rewritten as the real-valued model (1) by Thus, by the above relation, the ML detector (2) applies to the one-bit MIMO model (3).

Some Aspects
Some basic nature of the ML problem (2) should be noted. First, the objective function f of problem (2) is convex (this is mainly because − log Φ(x) is convex [45]). The convexity of f can be leveraged to develop efficient approximate ML detectors. In [15], the authors considered a convex sphere relaxation of the ML problem (2); specifically, min where · denotes the Euclidean norm. Second, it is natural to question whether we can reliably perform MIMO detection from one-bit observations. Consider the following result.
(b) the probability density function of the h i 's, denoted by q(h), is continuous on its support; provided the expectation exists. Here, P − → denotes convergence in probability; y and h represent random variables associated with the realizations y i 's and h i 's, respectively; the expectation E[·] is taken with respect to y and h. Then, the minimizer off (x) over R N is uniquely given by the true binary vector in the signal model (1). It follows that the ML problem has its solution uniquely given by the true binary vector.
The result in Fact 1 was first reported in [44,Lemma 2] for the case of i.i.d. Gaussian h and constant Euclidean-norm x, and here we show a more general result. Before giving the proof, let us first discuss the implications. Fact 1 suggests that if the number of antennas at the BS is very large (true for massive MIMO), then the ML problem (2) may lead to correct recovery of the true binary vector. In fact, this large-M recovery result holds not only for the ML problem, but also for unconstrained relaxation of problem (2) (i.e., replacing the constraint {−1, 1} N by R N ) and the sphere relaxation in (5); it also holds if the true vector x in the signal model (1) is drawn from a higher-order constellation set (or even R N ). In addition, the requirement with the channel distribution is quite general; e.g., it works for i.i.d. Gaussian channels, correlated Gaussian channels (with respect to users), or other continuously distributed channels (with support R N ).
Proof of Fact 1: Our proof is different from [44, Lemma 2], which uses stochastic orders. We employ a more basic proof, taking proof ideas from the consistency property of ML estimation. To avoid notation overlap, re-denote the true binary vector in the signal model (1) as x 0 . The probability mass function of y i given h i and x 0 is which can be shown from (1). We see that, for any x = x 0 , where the inequality is due to log(t) ≤ t − 1. The above inequality implies that x 0 is a minimizer of f (x) over R N . To show that x 0 is the unique minimizer, note that equality in the above equation holds if and only if p(y|h, x) = p(y|h, x 0 ) for every y ∈ {−1, 1} and h ∈ R N . The latter condition implies this is seen from (7) (the monotonicity of Φ should also be noted). Clearly the above equation does not hold for any x = x 0 , which means that there does not exist The proof is complete.

The Main Idea
Our strategy for tackling the ML problem (2) hinges on a very recently introduced penalty approach [39]. Consider a penalty, and possibly approximate, formulation of problem (2) for a given parameter λ ≥ 0. Intuitively, the idea is to encourage large value with every x 2 i by imposing the penalty term −λ x 2 in the objective, on the one hand, and limit x 2 i ≤ 1 on the other hand. In doing so, the optimal solution to problem (8) should be forced to x 2 i = 1, or x i ∈ {−1, 1}, if we apply a large λ. In fact, under a mild assumption, this intuition is correct: Theorem 1 (a rephrased version of Theorem 2 in [39]) Let f be a twice differentiable function, not necessarily the one in (2), and consider the corresponding problems in (2) and (8). Let L f > 0 be a Lipschitz constant of the gradient of f on [−1, 1] N , which must exist for twice differentiable f . For any λ > L f /2, it holds that 1 (a) any locally optimal solution to problem (8) lies in {−1, 1} N ; (b) any globally optimal solution to problem (8) is also that to problem (2); (c) if x is a stationary point of problem (8) and x does not lie in {−1, 1} N , then x must be either a local maximum or a saddle point.
Hence, for a sufficiently large λ, we can employ problem (8) as an equivalent formulation of the ML problem (2). As the main benefit, the penalty formulation (8) turns the discrete ML problem into a continuous, and convex constrained, optimization problem. As a result, we can use methods, such as the descent-based methods, to efficiently compute a stationary point of problem (8) (and hopefully a locally optimal solution to it). But we should also note that the penalty term −λ x 2 in problem (8) makes the problem non-convex, and a descent-based algorithm can converge to a poor local minimum. On the other hand, problem (8) for λ = 0, or problem (P 0 ), is convex. This gives an intuition that problem (P λ ) in (8) should be easy for small λ, and hard for large λ. Therefore, it is natural to consider the following optimization strategy. run a descent-based algorithm, with x k−1 as the starting point, to compute a stationary point of problem (P λ k ) in (8), and store the solution obtained as x k 7: until λ k is larger than a pre-specified threshold. 8: output x k The idea with the above strategy is to progressively increase the difficulty of the problem. Also, and just as important, we use the previous solution x k−1 in an effort to find a good solution to problem (P λ k ). Imagine this: If x k−1 is a globally optimal solution to problem (P λ k−1 ) and the change of λ k relative to λ k−1 is small, then the optimization landscape may undergo only mild changes, and a descent-based algorithm starting with x k−1 may "easily" descend to a close-by globally optimal solution to problem (P λ k ). Thus we may be able to find the ML solution by tracing a solution path of problem (P λ ), from small λ to large λ. We give the reader more insight by pictorially illustrating the above described idea in Fig. 1, and by displaying the landscape of a 2D instance of problem (P λ ) in Fig. 2.
Algorithm 1 may be taxonomized into the class of homotopy optimizaton methods; see [33][34][35][36][37][38] and the references therein. The principle of homotopy optimization is to first find a transformation, or a homotopy map, that maps the original problem to another problem. That transformation depends on a parameter, say, λ. For large λ, the transformed problem is close to the original problem but is hard to solve directly. For small λ, the transformed problem is easy to solve but poorly approximates the original problem. Then, we seek to find a solution (possibly approximate) to the original problem by attempting to trace the solution path of a sequence of such transformed problems, from easy to hard and in a gradually changing fashion, e.g., by the routine we saw in Algorithm 1 which is typical in homotopy methods.

How to Choose the Penalty Sequence {λ k }?
In the homotopy strategy in Algorithm 1, a crucial question is how the penalty parameter sequence {λ k } should be chosen. Having a small increase with λ k at each iteration may allow us to follow the solution path better, but it may take too many iterations to do so. Having a large increase with λ k , on the other hand, reduces the number of iterations but may also increase the risk of losing track of the solution path. By our experience, a heuristically chosen {λ k } works well-empirically. For example, we may choose λ k = λ k−1 c for some constant c > 1. But it is tempting to see whether some theory-guided selection rule exists. Here we show one such rule by drawing a connection with Lagrangian dual relaxation (LDR). We start with studying an equivalent formulation of the ML problem (2) where D = [−1, 1] N denotes the problem domain, and f ⋆ the optimal value. We are interested in the Lagrangian dual of the formulation in (9). Let be the Lagrangian of problem (9), and let (f) solution path Figure 2: An instance of the landscape of problem (P λ ) in (8), with N = 2. The contour is F λ (x); the gray area is the feasible set; the red circle is the optimal solution to problem (P λ ); the blue star is the optimal ML solution; the instance is a randomly generated one for one-bit MIMO detection, with M = 10, σ = 1.
be the dual function. The dual problem of problem (9) is where d ⋆ denotes the optimal value of problem (11). At this point, note that the minimization problem in (10) is equivalent to the penalty formulation (8). Also, recall from the basic concepts of Lagrangian duality that the dual problem (11) is convex, and the weak duality inequality f ⋆ ≥ d ⋆ holds.
LDR is a method that exploits the dual problem to approximate the original problem; see, e.g., [40,41]. It works by first finding the optimal solution to the dual problem (11), denoted herein by λ ⋆ , and then finding the solution x to the minimization problem in (10) for λ = λ ⋆ . The duality gap f ⋆ − d ⋆ provides strong indication of how well LDR approximates the original problem; the smaller the gap is, the better LDR should be. For the problem at hand, we show that the LDR in (11) is tight.
Proof: Letλ be any constant such thatλ > L f /2. We have d ⋆ ≥ d(λ) = f ⋆ , where the equality above is due to Theorem 1. This, together with There is a connection between the preceding homotopy strategy and the LDR here. Consider finding the optimal solution to the dual problem (11) via the projected subgradient method [46], given by Here, g(λ) denotes a subgradient of the dual function d at λ; µ k is a step size (see the literature [46] for step-size rules that guarantee that λ k will converge to an optimal solution); λ 0 , the starting point, is assumed to be non-negative. By the subgradient calculus [46], g(λ) is given by wherex λ ∈ arg min x∈D L(x, λ).
Putting (13)-(14) into (12), we can simplify the projected subgradient method (12) to where we have used λ 0 ≥ 0 and x 2 ≤ N for any x ∈ D. The above projected subgradient method is seen to be closely related to the homotopy strategy in Algorithm 1: the former also increases λ k at each iteration, and it requires us to solve problem (14)-an equivalent of the penalty formulation (8)-at each iteration. The challenge with realizing the projected subprojected method is that problem (14) is non-convex. But we can substitute the globally optimal solutionx λ k with an approximate solution, obtained by usingx λ k−1 to warm-start a descent-based algorithm. The resulting (approximate) projected subgradient method will then be identical to the homotopy strategy in Algorithm 1, with a clearly defined penalty update rule as shown in (15). Let us summarize. In the homotopy strategy in Algorithm 1, we may choose λ k by where {µ k } is a standard step-size sequence in the subgradient method. It is interesting to observe that if x k−1 is closer to {−1, 1} N , which implies a smaller N − x k−1 2 , then the increase of λ k will be slowed down-which seems to make sense intuitively.

The Descent-Based Algorithm Used
We complete our design by specifying the descent-based algorithm in line 6 of Algorithm 1. The constraint of problem (8) has a simple structure, and one can exploit such structure for efficient optimization via structured optimization methods-such as the projected gradient method. Here we employ a more advanced version of the projected gradient method which was numerically found to be very fast in a different application [39]. The aforementioned method, called gradient extrapolated majorization-minimization (GEMM), entails concepts from majorization-minimization and the accelerated project gradient method. Here we concisely state the method, and the reader is referred to [39] for detailed descriptions such as its intuitions and stationary-point convergence guarantee. Let ∇f (x) denote the gradient of a differentiable function f at x. Given a starting point x 0 , the GEMM method iteratively runs Here, Π denotes the projection onto [−1, 1] N , which has a closed form Π(x) = [ Π(x 1 ), . . . , Π(x N ) ] T , is the gradient of G λ (·|x) at x; β t is a step size; z t is an extrapolated point of x t and takes the form for some pre-specified extrapolation sequence {α t } (note that x −1 = x 0 ). Simply speaking, the GEMM method in (17) is an inexact majorization-minimization scheme that uses a one-iteration accelerated projected gradient update as its inexact update. It reduces to the projected gradient method if we set α t = 0 and replace ∇G λ (·|x t ) with ∇F λ (·), i.e., no extrapolation and no majorization, respectively. Let us examine the algorithmic details. We choose as our convex differentiable majorant (note that x 2 ≥ x 2 + 2 x, x −x , and f is convex differentiable). The gradient of the above majorant is where The step size β t is chosen such that the sufficient descent condition is satisfied. We use the backtracking line search [47] to find such a β t . The extrapolation sequence {α t } is chosen as that of FISTA [47], given by

A Numerical Issue and Its Fix
We should mention a numerical issue with the gradient-based algorithm in the preceding subsection.
In the gradient expression in (19), observe that the term e −x 2 /2 vanishes as |x| is very large. We found that the occurrence of such vanishing instances can substantially slow down the convergence speed of the gradient-based algorithm, and it may even lead to numerical instability. As a practical trick, we get this around by over-estimating the noise variance, specifically, by replacing the original σ with σ + σ 0 for some fixed σ 0 > 0. We found that this trick works empirically. On the other hand, doing so means that we actually implement a mismatched ML detector for some mismatched noise varianceσ 2 . By our numerical experience, we do not see noticeable performance degradation with the mismatched ML detector. We justify this by the following fact.
Fact 2 Consider the same settings as in Fact 1, but with the objective function f replaced by that in (22). Suppose that the probability density function of h is Gaussian with mean zero and covariance ρI for some ρ > 0. Then, the minimizer of the "large-M " objective functionf (x) in (6) over x 2 = N is uniquely given by the true binary vector. It follows that the mismatched ML problem has its solution uniquely given by the true binary vector. The above results hold for anyσ 2 > 0.
Fact 2 is a corollary of Lemma 2 in [44], which considers the no-mismatch caseσ 2 = σ 2 . Fact 2 suggests that, if the number of antennas at the BS is very large, the ML detector may be insensitive to the mismatch of the noise variance. Proof of Fact 2: First, we recall a basic result in stochastic orders [48]. Let ξ, υ be two continuous random variables, and let φ : R → R be a strictly increasing function. If ξ and υ have unequal probability distributions, then we have E[φ(ξ)] > E[φ(υ)]. Second, we apply the above result to the problem at hand. Re-denote the true binary vector in the signal model (1) as x 0 . Let x ∈ R N be any vector such that x 2 = N and x = x 0 , and let Note that φ is strictly increasing. It was shown in Lemma 2 in [44] that (23) holds, and ξ and υ have unequal probability distributions. Consequently we have and the minimum off (x) over x 2 = N is attained at, and only at, x 0 . The proof is complete.

Making the Homotopy Algorithm a Deep Learnt One
As mentioned in the Introduction, lately there has been growing interest in deep learning for MIMO detection via the deep unfolding approach [21,22,30]. To employ deep unfolding, one first needs to start with an existing algorithm that is iterative by nature. The deep unfolding approach sees each iteration of the algorithm as a network layer, and it seeks to find a better network by untying some of the existing algorithm's parameters and learning those parameters from data. Additionally, or alternatively, one may make the structure of each iteration more general, with the new structure controlled by some parameters; and then we learn those parameters from data.
The homotopy algorithm in the preceding section is very suitable for deep unfolding. To put into context, we first note that the homotopy algorithm in Algorithm 1, with the descent-based algorithm given by the one in Section 3.3, contains two loops-one for the update of the penalty parameter λ k , another for the iterative process of the descent-based algorithm. But we can unfold the two loops into one and write for some appropriate α k , β k , λ k ; cf. Algorithm 1 and (17). By putting the derivation of ∇G λ (x|x) in (19) into (24), and recalling the expression of z k , we can represent the whole algorithm by As mentioned, deep unfolding sees each iteration in (25) as a network layer, and the whole iterative process a deep network. Fig. 3(a) illustrates (25) in a network form. We see that Π and Ψ appear as nonlinear activation functions; G, α k , β k , λ k serve as weights. We apply deep unfolding to (25) by untying α k , β k , λ k , which are the extrapolation coefficient, step size, and penalty parameter, respectively. This means that we want to learn, from data, how the penalty parameters are adjusted. We should recall that the challenge with the homotopy method lies in the selection of the penalty parameters, and now we use data-driven learning to tackle the challenge. Similarly, we use data-driven learning to decide the step sizes and extrapolation. In addition, we make the structure more general by adding element-wise weights and biases in (25b). The network structure arising from the aforementioned untying and modification is given by where γ k is the untied parameter of 2β k λ k ; w k , b k ∈ R M are a weight and bias, respectively; ⊙ denotes the element-wise, or Hadamard, product. Fig. 3(b) illustrates the network structure of (26). The set of parameters to learn at each layer is θ k {α k , β k , γ k , w k , b k }. In the above deep-unfolded homotopy algorithm, we do not give it a staring point x 0 . Instead we learn a starting point. We generate x 0 by where W 0 ∈ R N ×M is a weight matrix and b 0 ∈ R N is a bias; both are to be learnt. We let Our training process is rather standard. The generative model y = sgn(Hx + v) in (1), or more precisely, the complex model (3) and the subsequent complex-to-real conversion (4), is used to generate a large number of training samples ( ; note that R is the number of samples, the x i 's are uniform i.i.d. generated, and the H i 's are generated from a statistical channel model such as the Rayleigh. The network parameters θ's are obtained by applying stochastic gradient descent to the empirical risk where the function ϕ(y, H, σ; Θ) represents the input-output relationship of the deep network, parameterized by Θ = (θ k ) K k=0 ; K is the number of layers.

Variation for Classical MIMO Detection
The preceding concepts for one-bit MIMO detection can also be applied to classical MIMO detection. The latter considers the unquantized model and the corresponding ML detector The homotopy algorithm in Section 3 directly applies by changing f to 1 2 y − Hx 2 . Recalling the algorithm representation in (24) and (26c), the homotopy algorithm for the classical MIMO case has the form (we obtain (28a) by applying ∇f (x) = H T Hx − H T y to (18) and (24)). The step size β k can be chosen as β k = 1/ H 2 2 where · 2 denotes the spectral norm; this is a standard method for fulfilling the sufficient descent condition (21) when f is convex quadratic [47]. For the deep-unfolded homotopy algorithm, we modify (28) as where α k , β k , ω k , γ k are the parameters to learn. Note that we train only four parameters at each layer (without counting the zeroth layer in (27)). The remaining details are essentially identical.

Simulation Results
In this section we show an extensive collection of numerical results to examine the performance of the homotopy algorithm and its deep-unfolded adaptation proposed in the preceding sections, and to provide benchmarking with the state-of-the-art algorithms.

Simulation and Algorithm Settings
We first describe how the simulations were prepared. The procedure is standard: We randomly generate the signal according to the complex-valued MIMO model (3) for the one-bit MIMO case, and its unquantized counterpart y C = H C x C + v C for the classical MIMO case. Then, we apply the complex-to-real conversion in (4) to obtain an instance of (y, H, x). Unless otherwise specified, the complex-valued channel H C is generated following the element-wise i.i.d. circular Gaussian distribution with mean zero and unit variance (i.e., the Rayleigh channel). The transmit vector x C is generated following the element-wise i.i.d. uniform distribution on the QPSK constellation set {±1 ± j}. We define the SNR as and we use the above formula to determine the noise variance σ 2 C (or its real counterpart σ 2 = σ 2 C /2) when the SNR is given. We use 100, 000 independently generated instances to evaluate the bit error rates (BERs) of the algorithms under test. We also evaluate the computational complexities by numerically counting the floating point operations (FLOPs) and also by measuring the actual runtimes on our computer. For fairness, the evaluations were done on the same platform and on the same computer; specifically, MATLAB 8.5, and a desktop computer with Intel i7-4770 processor and 16GB memory.
Next, we provide the implementation details with our proposed algorithms. For convenience, we name the homotopy algorithm in Section 3 Homotopy OpTimization ML (HOTML), and the deep-unfolded homotopy algorithm in Section 4 DeepHOTML; the same convention applies to their classical MIMO counterparts in Section 5. Let us first consider HOTML based on the representation in Algorithm 1. We initialize the penalty parameter as λ 0 = 0.01. We randomly initialize the algorithm by uniformly generating x 0 on [−1, 1] N . The update rule of λ k is (16), with µ k = 0.1/k for the one-bit MIMO case and µ k = 1/k for the classical MIMO case (a standard step-size rule in subgradient methods). We stop Algorithm 1 when |λ k −λ k−1 | ≤ 10 −4 . The descent-based algorithm inside Algorithm 1, which is described in Section 3.3, is stopped when x t+1 − x t ≤ 10 −4 or when the number of iterations exceeds a limit; that limit is 300 for the one-bit MIMO case, and 100 for the classical MIMO case. For the remedy of the numerical issue discussed in Section 3.4, we set σ 0 = 0.5.
The implementation details with DeepHOTML, which are mostly with training, are as follows. Unless otherwise specified, the number of network layers is K = 20. We implement the training process by Tensorflow for Python [49]. The generation of training samples is exactly the same as the signal generation described above. We use the ADAM stochastic gradient descent optimizer [50], with exponentially decaying step sizes, for training: specifically, the initial step size is 0.001; the step size decays by 0.9 for the one-bit case, and 0.95 for the classical MIMO case, once every 500 training iterations; each training iteration contains a batch of 500 training samples; we train the network with 10, 000 iterations. In addition, for the one-bit MIMO case, we do the following: every training sample has its SNR randomly drawn from a range of 5dB to 22dB, by uniform distribution; the network parameters w i 's and b i 's are initialized as i.i.d. Gaussian random vectors with mean zero and variance 0.01; we initialize β k = 0.01, γ k = 0.001, α k = 0.5 for all k. For the classical MIMO case the settings are similar, with the following differences: the SNR range is changed to 0dB to 18dB; we initialize β k = 0.01, ω k = −0.01, γ k = 0.001, α k = 0.5 for all k. The algorithms we benchmarked should also be mentioned. Table 1 provides a summary of the tested algorithms. These algorithms either are some of the de facto standards in MIMO detection, or are emerging methods. Some additional implementation details should be mentioned. We modify nML [15] by changing its step-size rule to the backtracking line search, which is also used in HOTML for one-bit MIMO detection; we found that this modification improves the performance of nML. The number of iterations of GAMP is set to 20, as recommended in [17]. The number of iterations of the row-by-row method [51] for SDR is 200. The number of iterations of LAMA is 100, the same one used in [11]; also we stop LAMA if the difference of successive iterates is less than 10 −4 . DetNet [22] has its source code available at https://github.com/neevsamuel/LearningToDetect.
We use that open source code to train DetNet under the recommended settings of 30 network layers, 50, 000 training iterations, and 3, 000 training samples for each training iteration. In this subsection we examine the one-bit MIMO case. Fig. 4 shows the BERs of the tested algorithms under different problem sizes (M, N ). We see that HOTML and DeepHOTML achieve much better BER performance than all the benchmarked algorithms, namely, the ZF detector, which is the direct application of zero forcing in classic MIMO detection; nML and its 2-stage variant, which are based on sphere relaxation of the ML problem (2) (cf., problem (5)); and GAMP which is the application of approximate message passing to one-bit MIMO detection. Particularly,  the benchmarked algorithms all appear to exhibit error floor effects, and we do not see the same effects with HOTML and DeepHOTML. HOTML and DeepHOTML generally yield similar BER performance.

One-Bit MIMO Detection
Next, we compare the computational complexities of the tested algorithms. Before we show the results, we should first discuss a subtle issue on operation counts. HOTML, DeepHOTML, nML and GAMP all require integral evaluations. In HOTML, DeepHOTML and nML, we need to frequently compute Φ(t) = t −∞ 1 √ 2π e −τ 2 /2 dτ -the cumulative distribution of a standard Gaussian distribution. GAMP requires computing the expectation and variance of some truncated Gaussian distributions, which can be done by computing Φ. The computation of Φ takes definitely more than one FLOP, although there exist highly specialized algorithms (e.g., erfc in MATLAB) for efficient computation of Φ. Hence we divide our operation counts into two, one as the FLOPs of usual operations (+, −, ×, /, log, exp), another as the number of times the function Φ is called.
The complexity results are shown in Table 2. We use the same settings as in Fig. 4, with the SNR fixed at 15dB. The fastest algorithm, as revealed by both the actual runtimes and operation counts, is DeepHOTML. GAMP and nML are the second and third best, respectively; HOTML is the slowest. It is worth noting that the computations of DeepHOTML are similar to those of a gradient descent method with a fixed number of iterations (or layers) of 20-this is why DeepHOTML is fast. The computations of HOTML are also similar to those of a gradient descent method. However, as suggested by Table 2, HOTML uses considerably more iterations than DeepHOTML; in fact, HOTML's line search routine for determining the step sizes also costs a non-negligible amount of computations.
It is also interesting to examine the BER performance of DeepHOTML under different number of network layers. Fig. 5 shows the results; again, the settings are identical to those in Fig. 4. Note that when we change the number of layers K, we train DeepHOTML for that particular K. We observe from Fig. 5 is that the BER performance improves as the number of layers increases. Also, it is encouraging to see that DeepHOTML with 10 layers can achieve BER performance similar to that with 20 layers; DeepHOTML with 5 layers also looks good. In this subsection we turn to the classical MIMO case. Fig. 6 shows the BERs of the tested algorithms for the relatively easier instances of overdetermined MIMO channels (i.e., M > N ). In the figures, "lower bound" is the BER performance when there is no interference between symbols. Note that SD is an optimal ML algorithm using some smart branch-and-bound search method, but still it is computationally prohibitive when N is large. In our simulation, we only tested SD for N = 40. Some observations are as follows. LAMA suffers from error floor effects for the case of (M, N ) = (60, 40), but it achieves near-optimal performance when the problem size increases to (M, N ) = (120, 80). LAMA appears to be favorable for large MIMO regimes, and we will see the same behaviors later. Also, SDR, DetNet, HOTML and DeepHOTML all achieve near-optimal performance. In the BER plots in Fig 7, we examine the more challenging instances of critically determined channels (i.e., M = N ). It is worth noting that DetNet, in its original paper [21,22], did not consider the critically determined cases. We tried our best to train DetNet in critically determined cases, but we were not too successful with obtaining satisfactory results as in the preceding overdetermined cases. In the case of M = N = 400, we were even unable to complete the training; we found that the training (implemented by Tensorflow) drew a very substantial amount of computational resources. Fortunately, for DeepHOTML, we did not encounter the same problem; this is likely because our DeepHOTML network has only 4 parameters per layer (without counting the 0th layer in (27)). Also, note that we did not run SDR for the case of M = N = 400; although SDR is known to have polynomial-time complexity, it is still too expensive to run SDR when the problem size is very large. We observe that DetNet does not perform well, LAMA performs well only when the problem sizes are large, and SDR, HOTML and DeepHOTML consistently show near-optimal performance.  In addition to the i.i.d. Gaussian channel simulations shown above, we are also interested in correlated MIMO channels, specifically,

Classical MIMO Detection
t , whereH is element-wise i.i.d. circular Gaussian with mean zero and unit variance; R r and R t are the spatial correlation matrices at the receiver and transmitter, respectively, and they are modeled i,j , otherwise for |r| ≤ 1 [52]. In the simulation below, we set r = 0.2. Also, DeepHOTML is trained under the SNR range of 18dB to 34dB. The other simulation settings are same as the i.i.d. Gaussian case above. Fig. 8 shows the BER results for M = N = 160. It is seen that both HOTML and DeepHOTML achieve near-optimal detection performance; SDR is only slightly worse; LAMA, which works very well in the large-scale i.i.d. Gaussian cases (recall Fig. 7(c)-(d)), performs poorly. In Fig. 9 we compare the complexities of the tested algorithms by examining their FLOPs under various problem sizes N ; the SNR is fixed at 10dB. We see that DeepHOTML stands as the fastest algorithm in general.
We finish by showing the BER performance of DeepHOTML for different numbers of layers in Fig. 10. The results indicate that DeepHOTML can achieve promising performance with the number of layers as small as 10.

Conclusion
To conclude, we developed a homotopy optimization algorithm for efficient high-performance MIMO detection under one-bit quantized or unquantized observations. We also studied the possibility of using deep unfolding to enhance the performance of our homotopy algorithm. Our numerical results illustrated that the homotopy algorithms, non-deep and deep, achieve promising detection performance. Also, the deep homotopy algorithm was found to be easy and stable to train for a variety of MIMO settings, and its operational cost very competitive compared to those of many existing MIMO detection methods. Our present study focused on binary symbol constellations, and we hope that our endeavor would provide further insights into attacking other types of symbol constellations, especially, by deep unfolding.