An Exploration of the
Heterogeneous Unsourced MAC
Abstract
The unsourced MAC model was originally introduced to study the communication scenario in which a number of devices with low-complexity and low-energy wish to upload their respective messages to a base station. In the original problem formulation, all devices communicate using the same information rate. This may be very inefficient in certain wireless situations with varied channel conditions, power budgets, and payload requirements at the devices. This paper extends the original problem setting so as to allow for such variability. More specifically, we consider the scenario in which devices are clustered into two classes, possibly with different SNR levels or distinct payload requirements. In the cluster with higher power, devices transmit using a two-layer superposition modulation. In the cluster with lower energy, users transmit with the same base constellation as in the high power cluster. Within each layer, devices employ the same codebook. At the receiver, signal groupings are recovered using Approximate Message Passing (AMP), and proceeding from the high to the low power levels using successive interference cancellation (SIC). This layered architecture is implemented using Coded Compressed Sensing (CCS) within every grouping. An outer tree code is employed to stitch fragments together across times and layers, as needed. This pragmatic approach to heterogeneous CCS is validated numerically and design guidelines are identified.
Index Terms:
Unsourced random access, Coded compressed sensing, Approximate message passing, Superposition constellation.I Introduction
The IoT paradigm of myriad unattended devices connected wirelessly to the Internet may pose a significant disruption to existing communication networks. The predicted number of such devices, orders of magnitude greater than human subscribers, and the usage profile of these devise, sporadic and fleeting, invalidate the type of connection-based architectures that form a foundation for existing deployments. Thus, new means of Internet access must be explored to reflect this change, with provisions for random access. Along these lines, one model attuned to this reality that has gained attention in recent years is unsourced random-access (URA). The URA formulation, originally proposed by Polyanskiy [polyanskiy2017perspective], centers on concurrent up-link data transfers. There is a strong connection between URA and Compressed Sensing (CS), with the former problem being an instance of a noisy support recovery task [choi2017compressed, reeves2012sampling, gilbert2017all]. More precisely, in URA, the receiver seeks to identify the set of messages being transmitted by active devices, without regard for the identities of their sources. The identity of a source can be embedded in the message payload, if needed. The value of this approach lies in the fact that the access point does not need to determine the set of active devices at the onset of a frame, a step that can rapidly become overwhelming for connection-less settings with a very large population of candidate transmitters. URA raises both theoretical and practical challenges. Achievable bounds rooted in finite-block length analysis for such systems can be found in [polyanskiy2017perspective]. These bounds are obtained devoid of complexity constraints, as they rely on joint maximum likelihood decoding.
Several pragmatic, low-complexity approaches for this problem have been proposed [ordentlich2017low, vem2019user, amalladinne2019coded, calderbank2018chirrup, fengler2019sparcs, pradhan2019sparseidma, marshakov2019polar, AKPolar]. Conceptually, each of these contributions offer a means to circumvent the difficulty associated with the dimensionality of the problem. Indeed, when viewed as a support recovery task, unsourced random access features a -sparse state vector of length or longer. This reality prevents the straightforward application of standard CS solvers. To address this issue, many algorithms leverage lessons from random access and coding theory to design structured sensing matrices suitable for the efficient recovery of the sent messages. A line of research that has attracted attention in this context is the framework of coded compressed sensing (CCS) originally proposed by Amalladinne et al. [amalladinne2018couple, amalladinne2019coded]. This scheme is a divide-and-conquer approach where a large CS problem is partitioned into smaller components, each of which can be solved using standard CS algorithms. The output of this step produces lists of message fragments, one list for every CS instance. The transmitted messages are recovered by stitching fragments together using an outer code. Overall the approach can be abstracted as a concatenated coding scheme where an inner code is task with fragment recovery and the outer code is responsible for message disambiguation.
CCS has been ported, enhanced, and extended by multiple authors. It appears as a component of the ultra-low complexity CHIRRUP algorithm [calderbank2018chirrup], and it can be incorporated into activity detection in multi-antenna systems [fengler2019massive]. CCS can be employed to build neighbor discovery schemes and to handle signal asynchrony [zhang2013neighbor, thompson2018compressed, amalladinne2019asynchronous]. An enhanced version of the algorithm takes advantage of the fact that output from the early stages of CCS can be integrated into later stages as side information to improve execution [amalladinne2020enhanced]. This variant has inspired significant extensions related to sparse regression codes and Approximate Message Passing (AMP) [fengler2019sparcs, amalladinne2020unsourced].
Along similar lines of research, the main contributions of our article can be summarized as follows.
-
•
In Sec. II, we introduce a novel system model for unsourced random access. This new model captures the fact that, in practice, wireless IoT devices may have distinct payload requirements. Heterogeneity is addressed by introducing the notion of clustering, whereby users within a cluster have the same power budget and they transmit at the same rate. We refer to this model as HetURA.
-
•
A pragmatic communication scheme for this setting is developed in Sec. III. The propose algorithm borrows ideas from CCS [amalladinne2018couple, amalladinne2019coded], but also introduces a phased decoding approach akin to successive interference cancellation across layers. Portions of clusters with greater energy budgets are decoded first. The structure of the problem is facilitated by a superposition constellation with two-levels.
The value of the proposed framework is examined in Sec. IV, where performance results showcase the validity of the approach. Finally, Sec. LABEL:sec:Conclusion concludes the paper.
II Heterogeneous URA
Our goal is to introduce and study a heterogeneous version of URA with groupings, where distinct groups have different power levels and data requirements. We refer to this model as the heterogeneous URA (HetURA). The HetURA is formally defined as the up-link scenario where the user population is divided in clusters, with cluster containing the set of devices . Of these devices, only a subset of size is active, with users therein wishing to communicate to the base station. The output at the receiver is then equal to
(1) |
where is the channel input of the user in the cluster, and is the block-length. Note in (1). Each input sequence is subject to an expected power constraint with cluster ordering . The components of additive noise are independent, each with a standard normal distribution.
A suitable transmission scheme for the HetUMAC is defined as follows. Active user in cluster wishes to transmit message , where denotes the rate of cluster . All the users within a cluster employ the same code and, hence, they share a same rate. This gives
(2) |
Having observed , the receiver is tasked with decoding the list of messages transmitted by each cluster; that is,
(3a) | |||
w |
ith . Every entry on this list should take value in the set . System performance is evaluated according to the per-user probability of error, defined as [polyanskiy2017perspective]
(4) |
In words, this captures the (maximum) probability that a message sent by one of the devices is not recovered at the receiver. Note that, since all the users in a cluster use the same encoding function, as in (2), the receiver does not discover which user transmitted which message.
III A Coded Compressed Sensing Scheme
In this section, we describe an extension of the work found in [amalladinne2019coded] adapted to the HetUMAC scenario discussed in Sec. II. To put our contribution in context, we begin with a brief review of key CS notions. The original URA formulation can be viewed as sparse support recovery from observation
(5) |
where is a dictionary of possible signals, is a binary vector that contains the indices of the transmitted codewords so that , and is additive noise as in (1). We stress that is a sparse vector with being equal to the number of active URA devices.
As mentioned above, this article explores the extended scenario where the device population is partitioned into groups, and users from distinct clusters employ different codebooks. For ease of exposition, we restrict our treatment to the case where . When two groupings are present, the CS interpretation of URA becomes
(6) |
In a manner analogous to the basic URA formulation, denotes the collection of indices from the first cluster; and , the indices from the second cluster. As in Sec. II, we assume that the clusters are ordered in increasing transmit power, so that we refer to the first/second cluster and low/high-energy cluster. For simplicity, we do not discuss this alternative in the paper. Recall that CCS was introduced as a means to tackle the dimensionality issue posed by the width of . Quite obviously, when expanding the sensing matrix to accommodate multiple groupings, a number of complexity issue arises. In particular, similarly to CSS, complexity allows for the decoding through non-negative least squares (NNLS) or LASSO only for limited problem dimensions in (6). To support longer transmission block-lengths, the transmitted bits are divide into fragments and sent in separate slots. Since the identity of the transmitter is not conveyed in the choice of encoding function, the individual fragments of the original messages must be pieced together through a low-complexity tree-based algorithm as in [amalladinne2019coded].
To further reduce decoding complexity, the users in the high-energy cluster transmit their message bits using a superposition constellation with two-layers: a top and a bottom layer. The symbols in the bottom layer are transmitted using the same code-book as the low-energy cluster, whereas the remaining bits are “on top” of the bottom bits using superposition constellation. This coding choice allows the receiver, for each transmission slot, to first decode the top layer of the superposition constellation in the high-energy cluster; and then, after using Successive Interference Cancellation (SIC), decode the low-energy users together with the bottom layer in the superposition constellation of the high-energy cluster. Upon decoding all the message fragments in all the slots and from all the users, the receiver can then employ the tree decoder to reconstruct the set of transmitted messages. We further detail the proposed transmission scheme below.
III-A Fragmenting
In the low-energy cluster, every message is converted into a binary vector and partitioned into sub-blocks, where the sub-block consists of bits, so that . This results in a collection of information fragments for message . On the other hand, users in the high-energy cluster first split their bits into two groups: one for the top layer and one for the bottom layer. Denote these two sets of bits by , for the top and bottom portions, respectively. Likewise, let , be the total numbers of bits assigned to these two layers; and , be the corresponding rates. Subsequently, the bottom bits are fragmented exactly as in the low-energy cluster to form the set . The top bits are also partitioned into fragments, but this time is the size of the fragment (not necessarily the same partitioning as in the bottom layer). Again, we must have and, additionally, .
III-B Tree Encoding
The role of the tree decoder is to enable the stitching of message fragments at the decoder. In CCS, this is accomplished by appending parity bits to the fragment based on the preceding information bits. Every device in the low-energy cluster takes the message fragment and encodes it into a vector using a systematic random linear code, together with the message fragment,
(7) |
where produces random parity bits from all the previous segments, and indicates modulo-2 matrix multiplication. Thus, is viewed as a binary vector. In this scheme, ; that is the first fragment does not contain any parity bits. In (7), , so that effectively we have random linear parity constraints embedded in this block to help stitch together fragments of information bits belonging to when decoding codeword .
A user in the high-energy cluster performs a similar encoding process. Redundancy for bottom bits is added paralleling the encoding in the low energy cluster, yielding
(8) |
where is the same binary matrix that appears in (7). The top bits are encoded according to the information bits in each cluster, i.e.,
(9) |
where is, again, a random parity generating matrix.
III-C Superposition Coding & CS Encoding
After tree encoding is complete, each encoded block has size . These blocks are then encoded using two set of inner CS codes: (i) one for the segments of the low-energy cluster and the bottom segments of the high-energy cluster; and (ii) one for the top segments of the high-energy users. To apply the inner encoding, we convert the binary string into the one-norm binary vector in which a single one is placed at the location corresponding to the integer value of . This is the emblematic index representation used in CCS. Blocks and are converted to their index representations in a similar manner.
The two CS code differ as follows: the former has entries from , while the latter features entries from . This difference in support results in a superposition constellation; the top bits are effectively transmitted at a higher power than the bottom bits, based on our assumption . Accordingly the CSS signal corresponding to section is
(10) |
where is a matrix formed by picking rows uniformly at random (excluding the row of all ones) from a Hadamard matrix of dimension and re-scaling them to meet the power constraint. Similarly, after tree encoding, the bottom bits are CS encoded,
(11) |
using the same sensing matrix. The top bits are processed using a different signal dictionary,
(12) |
The rows of matrix are also scaled versions of randomly selected rows from a Hadamard matrix (excluding the row of all ones).
Finally, the channel inputs are obtained by concatenating the partial signals. For the low-energy users, we get
(13) |
and, for the high energy users, we have
(14a) | ||||
(14b) | ||||
(14c) | ||||
O |
ver the ensemble of random coding parameters, we obtain expected transmit power
as mandated by the constraint associated with (1). The parameters of the scheme are summarized in Table. I.
III-D Channel Transmission/Reception
As the transmitted channel inputs are composed of coded segments of the same length, we observe that the CCS construction naturally maps to the CS interpretation in (6). To see this, let be the sum of coded fragments for , then let be the concatenation of the fragments as in (13). Define , and , in a similar manner. Let be the tensor product between and ; likewise, let be that between and . Then, we can express the received signal as
(15) |
The signal aggregate obtained by adding and has a sparsity of , whereas is sparse.
III-E Two-Phase Decoding
Upon getting observation , the receiver separates it into sections , each block corresponding to the summation of the sections , , and , as in (15). The receiver begins by decoding using the CSS algorithm with coding matrix . During this phase of the decoding process, it treats the remaining terms in as additional noise. Parameters are selected to make sure that this portion of the decoding process is successful with high probability. Furthermore, for ease of exposition, we assume that is correctly recovered, although in reality, an error at this stage will produce some interference at the subsequent stage.
Once is recovered, the decoder computes a residual, or effective observation, for every section,
In the spirit of successive interference cancellation, these sections, are then passed to the CSS algorithm with coding matrix and sparsity level .
The recovery algorithm we adopt for individual sections is an AMP-based CS solver [maleki2010optimally]. Such composite algorithms iterate through two equations:
(16) | ||||
(17) |
with initial conditions and . The function in (17) is the denoiser, which can take the form of a posterior mean estimate [Giuseppe] or a standard soft thresholding operator [daubechies2004iterative, beck2009fast]. Equation (16) can be interpreted as the computation of a residual enhanced enhanced with an Onsager correction [bayati2011dynamics, donoho2013information].
After converting the terms into , the tree decoder uses the random parity bits to stitch together the information bits from each of the users, thus reconstructing the transmitted terms and .111In actuality, one also needs some random parity bits to stitch together the top and the bottom bits from the high-energy users. For simplicity this coding step is not presented here, as it is analogous to the step in Sec. III-B.
The encoding and decoding process is also conceptually represented in Fig. 1. Successive steps in the scheme are represented in vertical sections, proceeding from left to right. Separated horizontal section represent the processing of three sets of bits: the bits from cluster 1, the bottom bits from cluster 2, and the top bits from cluster 2. In the figure “be2i” indicates the conversion from binary string of length to the index in the binary vector. Also, “concat” indicates the concatenation of the segment as in (13).
Quantity | Quantity | ||
---|---|---|---|
block-length | # fragments | ||
# clusters | len. low-energy fragments | ||
# active users | len. high-energy top fragments | ||
power constraint | len. high-energy top fragments | ||
transmission rate | len. tree-coded fragments | ||
# transmitted bits | len. CSS+tree-coded fragments |
.
IV Numerical Evaluations
We now turn to the numerical simulation of the scheme introduced in Sec. III. Generally speaking, we are interested in arguing that the scheme in Sec. III allows high-energy users to transmit at high rates while preserving the baseline performance in which all nodes, i.e. , transmit at the low-energy level as in [amalladinne2019coded]. Indeed, this is the design reasoning behind the coding choice of treating the bottom bits of the high energy cluster as the bits in the low energy cluster. Accordingly, in the simulations we fix scheme parameters in Table II and study the rate performance as a function of while is kept fixed.
Parameter | Value | Parameter | Value |
---|---|---|---|
block-length | # of fragments | ||
# low-energy users | section length | ||
# high-energy users | # of AMP iterations | ||
low-energy payload | target | 5% |
IV-A Baseline Performance
In this section, we elaborate on the baseline settings for our simulation campaign. The performance associated with the original CSS code in each fragment is plotted in Fig. 2 for the settings in Table II.
Let us consider the performance of the classic (coordinated) RA scheme in which each active user transmits using time-sharing for a portion of the time. In this case, the largest attainable rate (ignoring the block-length effects) is : note the CCS code here attains reliable decoding up to but shows a saturation at .
To attain the desired block-length, the various fragment is stitched together using a tree code expressed as where the element of is in (7). With this choice choice of tree-coding parameters, we achieve an error rate below at the tree decoder.
IV-B Comparison with TDMA
Next, we wish to compare the performance of the scheme in Sec. III with the simpler scheme relying time-division multiple access (TDMA) as follows. Given a block-length , transmission takes place in a low-rate phase of duration and a high-rate phase of duration . In the low-rate phase, all users send at the baseline rate in Sec. IV-A at power while, in the high-phase rate, the high-rate users transmit at rate the baseline rate for users at power obtained as
(18) |
Let the rate attained with this scheme in the two clusters as . We can compare the performance of this TDMA approach with the approach in Sec. III by letting the rate in the low-energy user be and see what rate for the high-energy user is attainable. We can then interpret and as the rates that the two approaches afford the high-energy users for a given degradation of the baseline performance.
IV-C IAN improvement
Thorough numerical experiments, we have noted that the decoding procedure in Sec. III-E actually greatly outperforms the performance predicted by SIC assuming that the effecting noise