Low Complexity Detection using Likelihood Based Tree Search for Large MIMO Systems Saksham Agarwal (13603) Mentor - Dr. A. K. Chaturvedi November 9, 2016
Introduction 5G - the upcoming wireless standard Large MIMO systems form one of its crucial components Number of antennas to be scaled up Detection problem for Large MIMO pose a challenging task Available simple detectors are infeasible Near ML Detectors like Sphere Decoder have exponential complexity MMSE degrades performance with increasing antenna size
Detection techniques for Large MIMO Likelihood Ascent Search (LAS) & Reactive Tabu Search (RTS) Find solutions searching around neighborhood of an initial guess (like MMSE) Polynomial complexity in antenna size However face performance degradation and complexity increase upon increasing constellation size QP based detection Single stage QP detector 2-Stage and Multi-Stage (used in Branch and Bound, to be discussed next) QP detectors have better performance than LAS & RTS without degradation at high modulation scheme Multi-stage QPs can have high complexity alongside too
System Model MIMO system with N t transmit and N r receive antennas following V-BLAST architecture. The MIMO channel model given by: y = ˜ x + ˜ ˜ H˜ n x N t ] T ∈ C N t × 1 denotes the transmitted signal where ˜ x = [˜ x 1 , ˜ x 2 , ..., ˜ y N r ] T ∈ C N r × 1 received vector, ˜ H ∈ C N r × N t vector, ˜ y = [˜ y 1 , ˜ y 2 , ..., ˜ n ∈ C N r × 1 is the channel gain matrix with C N (0 , 1) elements and ˜ denotes the complex AWGN vector with i.i.d C N (0 , σ 2 ) entries.
Problem Formulation The ML solution given by x ∗ = arg min y − ˜ x || 2 ˜ X Nt || ˜ H˜ 2 x ∈ ˜ ˜ where ˜ X N t denotes the set of all possible transmit vectors. The problem converted to equivalent real-valued model: y = Hx + n y )] T , x = [ ℜ ( ˜ x )] T , n = [ ℜ ( ˜ n )] T where y = [ ℜ ( ˜ y ) ℑ ( ˜ x ) ℑ ( ˜ n ) ℑ ( ˜ H )]. Here x ∈ R 2 N t with and H = [ ℜ ( ˜ H ) −ℑ ( ˜ H ); ℑ ( ˜ H ) ℜ ( ˜ [ x 1 , x 2 , ..., x N t ] equal to the real part and [ x N t +1 , x N t +2 , ..., x 2 N t ] to the complex part of ˜ x and similarly for y , n and H .
Problem Formulation (contd.) The equivalent real model: x ∗ = arg min x ∈X 2 Nt || y − Hx || 2 2 √ √ where X ∈ {− P + 1 , ..., − 1 , 1 , ..., P − 1 } and P is the QAM √ constellation size. Using z = x +( P − 1) , we get: 2 1 z ∗ = arg min 2 z T Qz + b T z z ∈ Λ 2 Nt √ P − 1 } , Q = H T H is a symmetric positive where Λ ∈ { 0 , 1 , 2 , ..., √ semidefinite matrix and b = − H T ( y + ( P − 1) H1 ) / 2
Problem Relaxation Consider the following relaxed problem: 1 2 z T Qz + b T z arg min z √ subject to 0 ≤ z ≤ ( C − 1) 1 The required problem is a convex QP Can be solved using iterative techniques like interior point method Why interior point? It solves QP in almost constant number of iterations in practice, independent of problem dimension! Thus complexity does not increase exponentially by antenna size
Solution Strategy Why problem relaxation? The unrelaxed problem represents generic Integer Programming problem Finding exact solution is NP hard! Can only generate approximations in polynomial time complexity z = R ( z ∗ ), where R denotes the A simple approximation - use ˆ rounding function and returns the nearest integer to the optimal solution of the relaxed problem Used in one-stage QP detector Solution need not always be nearest integer (hard to imagine, but true!) How do we improve?
Branch and Bound Algorithm Standard IP algorithm to provide optimal result Exponential in complexity Solves problem using Divide and Conquer Strategy Recursively solves relaxed problem on reduced search space Checks if an integer vector from the reduced search space can produce an optimal solution If yes, then repeat the process after fixing bounds as integer values on one of the vector bit and further reducing the search space Let’s see an example!
Branch and Bound (contd.) Figure: Progress of Branch and Bound Image credits - https://optimization.mccormick.northwestern.edu/
Practical Implementation Many issues to keep in mind - branching, node selection, pruning and heuristics Branch and Bound effectively scans each and every integer in the worst case scenario! Exponential Complexity Although produces ML result, can’t be implemented Can we approximate?... Yes! Deeper we search in tree, closer to the solution we get Limiting a max depth can help us settle with a max complexity and a desired accuracy Used in Controlled Branch and Bound 1 But can we do better? 1 Elghariani, Ali, and Michael Zoltowski. ”Low Complexity Detection Algorithms in Large-Scale MIMO Systems.” IEEE Transactions on Wireless Communications 15.3 (2016): 1689-1702.
Scope for Improvement The branching in strategy in Controlled BnB ”dumb” - is independent of the problem at hand Looks for a lot of nodes in the search tree which (usually) do not return potential solutions Can we use problem structure to branch intelligently? Yes! Here’s what we proposed
Error Likelihood Metric The following quantity 2 η i = ( y − Hx ) T H i || H i || provides the probability that value of i th bit in the received signal vector might be in error. Here, H i denotes the i th column of the channel gain matrix H . We call the bit with index j = arg max i η i as error bit, as it has the highest probability of being in error. 2 A. K. Sah and A. Chaturvedi, ”Reduced neighborhood search algorithms for low complexity detection in mimo systems,” in 2015 IEEE Global Communications Conference (GLOBECOM), pp. 1-6, IEEE, 2015.
Likelihood Based Tree Search While branching in the search tree, we make use of the error likelihood metric It incorporates the detection problem structure at hand into the search process We branch upon the bit value, which is most likely to be in error Hence, our reduced search space does not contain the erroneous bits and provides us efficient tree search
Likelihood Based Tree Search (contd.) Hence, if the error index is j , the newly created nodes will have reduced search space: � node . lb i ≤ z i ≤ node . ub i , if i � = j node 1 : node . lb i ≤ z i ≤ ⌊ z i ⌋ , if i = j � node . lb i ≤ z i ≤ node . ub i , if i � = j node 2 : ⌈ z i ⌉ ≤ z i ≤ node . ub i , if i = j Here node denotes the currently selected problem instance to solve and lb i and ub i are the respective lower and upper bound on i th index of the solution vector node . zval . Therefore, this reduced the search space does not include the error bit value.
Likelihood Based Tree Search (contd.) Since our branching strategy is more reliable, we can be more confident that our branched node would contain the optimal solution How can we reduce complexity based upon this advantage?
Pruning Parameters depth provides a check on max tree size if our branching decision is correct, we need not explore tree at much lower depth as we’ll see in simulation results, our intuition did turn out to be true! breadth the error bit discussed before need not always be in error what could be the next likely bit in error? breadth allows us to use as many error bits creates that many sets of nodes, each with corresponding error bit We create breadth sets of new nodes as with corresponding error bits as follows: sort η = { η i : i = 1 , 2 , ..., 2 N t } and store it to η sort ErrorBit j = η sort [2 N t − j + 1] ∀ j = 1 to breadth
Pruning Parameters (contd.) keep main aim for this parameter was to limit the nodes explored, hence the complexity idea is that at every iteration, when we select a node to branch upon, we select keep many best nodes and prune the rest should work if the tree search was efficient simulations show positive results
Algorithm node with least optimal objective function value defined as best node prune nodes other than the best keep nodes branch upon the best node and create breadth sets of new nodes prune those which reached tree height greater than depth repeat the process until there is no new node to explore
Complexity Analysis The number of iterations of interior-point QP solver independent of problem dimension (the antenna size) 3 Complexity follows O ( n 3 ) for each iteration Hence, there is only a polynomial gain in complexity with increase in antenna size The computations required for solving each node remain roughly the same throughout the tree Hence, complexity mainly dependent upon the number of nodes explored For keep = 1, number of nodes explored = b × d 3 Gondzio, Jacek. ”Interior point methods 25 years later.” European Journal of Operational Research 218.3 (2012): 587-601.
Simulation Results I × 10 5 10 0 10 BnB(3,3) BnB(3,3) 9 2-QP 2-QP LTS(3,3,1) LTS(3,3,1) 8 10 -1 Number of Computations 7 Bit Error Rate 6 10 -2 5 4 3 10 -3 2 1 10 -4 0 0 5 10 15 20 0 5 10 15 20 E b /N 0 E b /N 0 Figure: Bit Error Rate and Number of Computations for32 × 32 16 QAM system for Likelihood Tree Search (LTS( d , b , k )), controlled BnB( L , M ) and 2 stage QP algorithms are shown against the average transmit SNR value ( E b / N 0 ).
Simulation Results II × 10 6 10 0 10 BnB(3,3) BnB(3,3) 9 2-QP 2-QP LTS(3,3,1) LTS(3,3,1) 8 10 -1 Number of Computations 7 Bit Error Rate 6 10 -2 5 4 3 10 -3 2 1 10 -4 0 0 5 10 15 20 0 5 10 15 20 E b /N 0 E b /N 0 Figure: Bit Error Rate and Number of Computations for 64 × 64 16 QAM system.
Recommend
More recommend
