An Efficient Compressive Sensing Event-Detection Scheme for Internet of Things System Based on Sparse-Graph Codes

Abstract

This work studied the event-detection problem in an Internet of Things (IoT) system, where a group of sensor nodes are placed in the region of interest to capture sparse active event sources. Using compressive sensing (CS), the event-detection problem is modeled as recovering the high-dimensional integer-valued sparse signal from incomplete linear measurements. We show that the sensing process in IoT system produces an equivalent integer CS using sparse graph codes at the sink node, for which one can devise a simple deterministic construction of a sparse measurement matrix and an efficient integer-valued signal recovery algorithm. We validated the determined measurement matrix, uniquely determined the signal coefficients, and performed an asymptotic analysis to examine the performance of the proposed approach, namely event detection with integer sum peeling (ISP), with the density evolution method. Simulation results show that the proposed ISP approach achieves a significantly higher performance compared to existing literature at various simulation scenario and match that of the theoretical results.

1. Introduction

Recently, compressive sensing (CS)  [1,2] theory has been widely used in the Internet of Things (IoT) system [3,4,5,6] and has shown significant performance improvements in network life, energy efficiency, and overall system throughput. CS theory is profitable to IoT system since it usually has limited perception, limited memory, and a small communication bandwidth and capacity [7,8,9].

In this paper, we investigate how to employ CS in wireless sensor networks, which involve a large number of sensor nodes. A typical scenario is an event-detection problem in the wireless sensor networks where a group of monitoring sensors try to capture few active event sources from many event resources. Specifically, we focus on two issues of wireless sensor networks. First, compared with the total number of sensors in the network, the number of active sensors is very limited. In addition, the number of events is much smaller than the number of all sources. Second, different events may occur at the same time and cause interference to detect them separately. As a result, the received signals are all superimposed, and an effective algorithm is needed to separate the signal $\mathbf{x}\in {\mathbb{R}}^n$.

Generally, consider the estimation of an unknown real-valued signal vector $\mathbf{x}\in {\mathbb{R}}^n$ from a vector of linear measurement $\mathbf{y}\in {\mathbb{C}}^m$ ($m<n$), i.e.,

$$\mathbf{y}=H\mathbf{x},$$

(1)

where $H\in {\mathbb{C}}^{m\times n}$ is often referred to as a measurement matrix, the number of nonzero elements of x is small, $k\ll n$, and k is known as the sparsity of x.

More specifically, we show that the sensing process in an IoT system produces an equivalent integer CS using sparse graph codes at the sink node. For this, one can devise a simple deterministic construction of the sparse measurement matrix and an efficient integer-valued signal recovery algorithm. Furthermore, many practical IoT systems can be modeled as integer CS based on sparse measurement matrices.

Similarly to traditional CS, the two main concerns in the integer CS of IoT systems are: (1) designing the measurement matrix H and (2) recovering $\mathbf{x}$ from the measurements $\mathbf{y}$ by exploiting the sparsity constraint and integer property of $\mathbf{x}$.

In this paper, we focus on deterministic as opposed to random measurement matrices for integer CS of IoT systems. The deterministic matrices are useful since in practice, the matrix H in Equation (1) has to be a deterministic matrix. Furthermore, by designing the proper matrix, we can improve certain features on CS of IoT systems such as recovery computational complexity and compression ratio.

Specifically, we mainly study the construction of the sparse measurement matrix and the reconstruction algorithm with integer CS based on sparse-graph codes. On the one hand, the sparse measurement matrix and reconstruction algorithm based on sparse-graph codes simplifies the construction process and lowered the measurement dimension, which is convenient for practical application.

The construction of measurement matrix must be guaranteed that each measurement can uniquely reconstruct the original signal. For example, suppose $h_1+h_2=h_3$, where $h_1,h_2,h_3$ is the linear projection coefficient. If the binary signal $\mathbf{x}$ is measured, the measurement is denoted as $h_1{x}_1+h_2{x}_2+h_3{x}_3=h_3$. However, two possible solutions are obtained by measurement: $x_1=x_2=0$, $x_3=1$ and $x_1=x_2=1$, $x_3=0$. Obviously, the matrix design does not meet the uniqueness requirement. In this paper, we mainly focus on the construction of deterministic sparse matrices and their reconstruction algorithms for integer CS of IoT systems. Our idea comes from the concept of algebraic numbers and their minimum polynomials in number theory, which ensures the uniqueness of integer signal reconstruction. The main contributions of this paper are as follows:

(1)

Using the sparse-graph codes in channel coding and integer CS of IoT systems, we design a new class of deterministic sparse measurement matrices which are sufficient to guarantee the unique recovery for integer CS of IoT systems.

(2)

By exploiting the integer-valued structure of the event-detection signal and sparse measurement matrix, an efficient event-detection signal recovery algorithm is proposed. Furthermore, the asymptotic analysis is also conducted on the performance of the recovery algorithm with the density evolution method.

(3)

In order to deal with the noise, the above-mentioned measurement matrix design is extended to the noisy situation, and an effective reconstruction criterion under the noise condition is proposed.

Throughout this paper, we use the following notations. For a vector $\mathbf{x}$, $x_i$ denotes the the i-th entry of $\mathbf{x}$. For a matrix H, we use ${\mathbf{h}}_i$ to denote the i-th row of matrix H, the transpose of matrix H is denoted by $H^{\prime }$. For any support set $\mathsf{\Gamma }$, the cardinality of $\mathsf{\Gamma }$ is denoted as $\left|\mathsf{\Gamma }\right|$, ${\mathbf{x}}_{\left\{\mathsf{\Gamma }\right\}}$ denotes a vector of length $\left|\mathsf{\Gamma }\right|$ taken from $\mathbf{x}$ with support set $\mathsf{\Gamma }$.

2. Related Work

Several approaches have used CS theory for event detection problem. For example, the multivariated Bayesian compressive sensing (BCS) approach has been adopted in [10] to settle the event detection problem in the IoT system; however, the multivariated BCS approach is known to be sensitive to noise, resulting in poor performance in low signal-to-noise ratios (SNRs). To settle this problem, Eltabie et al., in [11], proposed the use of assisted compression to model the dense IoT problem. However, massive sensor nodes must be employed in the sensing field to guarantee its performance. Generally, the event detection problem in IoT system can be modeled as a integer compressive sensing problem.

In traditional CS, the sparse signals are defined over the field of real numbers. However, in practice, the alphabet of the sparse signal can be modeled as a finite set of integers. For example, blind estimation in digital communications [12], binary sparse signals [13,14], and other counting data sets, including arrivals at a queue/server, are inherently integer-valued. In such cases, it is called integer CS [7,15,16], where knowledge of the sparsity and the integer property can prove to be useful.

Most of the measurement matrices in the event-detection problem of the IoT system are based on randomization, such as the i.i.d Gaussian random matrix [7,17]. In general, the exact solution to the second concern is shown to have a combinatorial nature and the computational time becomes exponential [17]. However, if both the sparsity and the integer-valued features are exploited, some efficient algorithms, such as sphere decoding and CVX in convex programming, can be performed. In this case, the exact exhaustive search with the same solution for almost all the possible inputs would not be necessary [13,17].

Most of the works on event-detection algorithms of the IoT system are based on the random matrix [13,14,18]. In [13,14], the authors focused on the binary sparse signal. The problem of detecting the entries of binary signal was formulated as a Bayesian framework in [13]. M. Shirvanimoghaddam et al. proposed a binary signal-recovery approach based on analog fountain codes. In [7], the authors provided a link between superimposed codes (SC) and integer CS, where the new codes, termed as weighted superimposed codes (WSC), were proposed.The number of required signal measurements in WSC is of $\mathcal{O}(klogn/logk)$, which is less than the standard $\mathcal{O}(klog(n/k\left)\right)$. In [17], to reduce the computational complexity of the recovery, the authors solved the problem by minimizing the sum of weighted absolute values. However, the probability distribution defined on an alphabet should be known. In [19,20,21,22], the authors considered compressed sensing over a finite alphabet, where the elements of the measurement matrix are also in a finite alphabet. In this paper, we revisit the event-detection problem in an IoT system from the coding theory perspective and solve the problem as a decoding problem.

3. System Model and Problem Formulation

3.1. System Model

The n event sources in the IoT system, denoted as ${\mathrm{E}}_1,{\mathrm{E}}_2,\cdots ,{\mathrm{E}}_n$, are randomly distributed in the detection area $\mathsf{\Xi }$, as shown in Figure 1. Each event source ${\mathrm{E}}_i$ randomly generates an event $x_i$ which can be detected by the sensor nodes in the area. Since only the active state of the event source is detected, the event $x_i$ is defined as a binary signal, indicating that the event $x_i=1$ is an active event, and the event $x_i=0$ is an inactive event. Note that the number of simultaneous active events is k ($k\ll n$), so the vector $\mathbf{x}$ is a n-dimensional k-sparse binary vector.

Assuming that there are m sensors used to monitor the event source in the area, its monitoring range is $R_{\mathsf{\Xi }}$, then each sensor can monitor the event source of the distance sensor at most $R_{\mathsf{\Xi }}$. Denote $h_{i,j}$ as the channel of the i-th event source and the j-th sensor, then the signal $y_j$ received by the j-th sensor is:

$$y_j=\sum _{i\in {\mathsf{\Xi }}_j}{h}_{i,j}{x}_i+n_j,$$

(2)

where ${\mathsf{\Xi }}_j$ is the event source within the monitoring range of the j-th sensor, and $n_j$ is noise. Its vector form is:

$$\mathbf{y}=\mathbf{Hx}+\mathbf{n}.$$

(3)

Generally, sensors are randomly distributed in the monitoring area; event sources that are not within the monitoring range cannot be monitored. In other words, when the total monitoring area $\mathsf{\Xi }$ is large, most elements $h_{i,j}$ are zero, thus, the matrix $\mathbf{H}$ is sparse. Therefore, when the number of sensor nodes is less than the number of event sources ($m<n$), the monitoring model of active events in the wireless sensor network can be regarded as an integer compressed sensing model based on a sparse measurement matrix. In addition, the detection of the positioning signal in GPS system can also be regarded as a sparse matrix and an integer compressed sensing model.

3.2. Problem Formulation

Generally, the event detection problem in IoT systems can be modeled as a integer CS problem. Given $k,n,q\in \mathbb{N}$ with $k\ll n$, and a finite alphabet $\mathcal{X}=\{{\chi }_1,{\chi }_2\cdots {\chi }_q\}\subset \mathbb{Z}$ with $0\in \mathcal{X}$ and $\left|\mathcal{X}\right|=q$, we consider the following ensemble:

$$\mathcal{S}=\{\mathbf{x}=(x_1,x_2,\cdots ,x_n)\in {\mathcal{X}}^n:{∥\mathbf{x}∥}_0=k\}$$

This ensemble represents the space of n-dimensional signals that are k-sparse with entries coming from $\mathcal{S}$.

In [17], the authors discussed the uniqueness of the solution of the discrete signal recovery. If the pair $(\mathcal{X},H)$ is chosen to satisfy:

$$kerH\cap {\tilde{\mathcal{X}}}^n=\left\{\mathbf{0}\right\},$$

(4)

where $kerH\triangleq \{\mathbf{x}\in {\mathbb{C}}^n:H\mathbf{x}=\mathbf{0}\}$ and $\tilde{\mathcal{X}}\triangleq \{r_i-r_j:i,j=1,2,\cdots q\}$, then the linear equation associated with measurements in (1) have a unique solution.

As long as the uniqueness assumption holds, the exact solution can be obtained in a finite number of steps by enumerating all possible ${\mathcal{X}}^n$ in ensemble $\mathcal{S}$. By denoting ${\mathcal{X}}^n=\{{\mathbf{x}}_1,{\mathbf{x}}_2,\cdots ,{\mathbf{x}}_{\mu }\}$, we can uniquely determine the values of $\mathbf{x}$ in a finite time by comparing the measurement vector $\mathbf{y}$ and $H{\mathbf{x}}_i$ ($1⩽i⩽\mu$). However, the computational complexity of this enumerating computation is exponential. For example, when $q=3$ and $n=1000$, the number of comparisons is $\mu =3^{1000}$ in the worst case.

To reduce the computational complexity, we borrow the insights of sparse graph codes in channel coding and CS [23,24]. Our basic design is that if each row of H, say ${\mathbf{h}}_l$, is sparse (most of the elements in ${\mathbf{h}}_l$ are zero), then each measurement ${\mathbf{h}}_l\mathbf{x}$ may only involve few nonzero elements of $\mathbf{x}$ since most of elements of $\mathbf{x}$ are also zero; thus, the size of the problem is reduced significantly, and the few nonzero elements of $\mathbf{x}$ can be recovered by the efficient enumerating method in an iterative manner.

4. Event Detection Using Sparse Graph Codes

This section first briefly presents a bipartite graph. Then, we explain that the event-detection problem in the IoT system is a special case of sparse graph decoding, so it can be solved with fewer measurements, by the standard peeling decoding algorithm, compared with the existing methods. We further design the measurement matrix and obtain the lower bound of the minimum number of sensor nodes required to successfully capture all active events.

4.1. Preliminaries

Any sparse matrix can be efficiently represented by a bipartite graph. Let $G=(\mathcal{V}\cup \mathcal{C},\partial )$ denote a bipartite graph with variable nodes set $\mathcal{V}$, check nodes set $\mathcal{C}$, and the edge set ∂; every edge in ∂ connects a node $v_i$ in $\mathcal{V}$ to a node $c_i$ in $\mathcal{C}$. Additionally, let $\tilde{H}$ denote the bi-adjacency matrix of bipartite graph G:

$${\tilde{H}}_{i,j}=\left\{\begin{array}{c}1,\mathrm{if}\{v_i,c_j\}\in \partial \\ 0,\mathrm{if}\{v_i,c_j\}\notin \partial \end{array}\right.$$

In a bipartite graph, a node in $\mathcal{C}$($\mathcal{V}$) has degree i when it connects to i nodes in $\mathcal{V}$($\mathcal{C}$). Let ${\lambda }_i$ denote the fraction of nodes with degree i in $\mathcal{V}$, ${\rho }_j$ denote the fraction of nodes with degree j in $\mathcal{C}$, and let

$$\lambda \left(x\right)={\sum }_i{\lambda }_i{x}^{i-1},\rho \left(x\right)={\sum }_j{\rho }_j{x}^{j-1}$$

represent the degree distributions.

When the measurement matrix is sparse, the event detection problem in the IoT system also can be represented by a bipartite graph, where the sets of signal coefficients and measurements are mapped to the variable nodes set $\mathcal{V}$ and check nodes set $\mathcal{C}$, respectively. In this paper, we denote the set of variable nodes that incident to check node l by $\mathcal{N}\left(l\right)=\{i:h_{l,i}\ne 0\}$.

Since the event source generates integer-value signals, the event vector can be regarded as integer-value symbols during sparse graph coding. During sensing, the vector is multiplied by the channel matrix H and sent to the sink node for further processing. Since we assume that each sensor node only receives signals from event sources in the sensor coverage area, the nonzero entries in each row of H are very small. This is very similar to the sparse graph coding process, where the generator matrix is now the channel matrix and the weight coefficient is the channel gain. More specifically, the degree of each coding symbol (measurement or sensor) is represented by the sensor degree, which is now the number of event sources. In addition, the number of nonzero elements in the corresponding row of the generator (or measurement) matrix is determined by these sources. By treating each event source (information symbol) and sensor reading (coding symbol) as variables and check nodes, respectively, the measurement process in the IoT system can be represented by a weighted bipartite graph. The construction of measurement matrix is given as follows.

4.2. Measurement Matrix Construction

We construct the measurement matrix using the row tensor product given in [25].

Definition 1

(row tensor product).Let A be a $t_1\times n$ matrix and B a $t_2\times n$ matrix, with rows $\{A_i:1\le i\le t_1\}$ and $\{B_j:1\le j\le t_2\}$, respectively. The row tensor product $S=A{\otimes }_{r}B$ of A and B is a $t_1{t}_2\times n$ matrix whose rows are $\{A_i{B}_j:1\le i\le t_1,1\le j\le t_2\}$, where $A_i{B}_j$ denotes the component wise product of two vectors of length n.

The measurement matrix is generated from the sparse bi-adjacency matrix $\tilde{H}$ of the bipartite graph G. The main focus of this paper is on the left d-regular (all variable nodes have the same degree d) bipartite graph, i.e., $\lambda \left(x\right)=x^{d-1}$. The results, however, can be generalized to regular or irregular cases.

Definition 2

(measurement matrix).Given a $m\times n$ sparse bi-adjacency matrix $\tilde{H}$ of left-regular bipartite graph and a complex vector $\mathbf{f}=[1,\cdots ,e^{j2\pi (i-1)/p},\cdots ,e^{j2\pi (n-1)/p}]$, the $m\times n$ measurement matrix H is given by

$$H=\tilde{H}{\otimes }_r\mathbf{f},$$

(5)

where $p\ge n$ is a constant prime.

To guarantee the exact recovery of all the k-sparse integer-valued signals, the measurement matrices should be designed first, i.e., satisfying Equation (4), which is able to uniquely determine the signal coefficients. For the constructed measurement matrix, the following theorem holds:

Theorem 1.

For the measurement matrix H constructed as (5), the condition $kerH\cap {\tilde{\mathcal{X}}}^n=\left\{\mathbf{0}\right\}$ holds for the pair $(\mathcal{X},H)$.

To proof this theorem, we need some notations.

Definition 3

(algebraic number minimal polynomial).The minimal polynomial of an algebraic number ς is the unique irreducible monic polynomial of smallest degree $q\left(x\right)$ with rational coefficients such that $q\left(\varsigma \right)=0$ and whose leading coefficient is 1.

For the algebraic number $e^{j2\pi /p}$ (p is a prime), the minimal polynomial is ${\mathsf{\Phi }}_p\left(x\right)={\displaystyle \sum _{i=1}^p}{x}^{(i-1)}$.

Lemma 1.

For ${\alpha }_i\in \mathbb{Z}$, the equation ${\displaystyle \sum _{i=1}^p}{\alpha }_i{e}^{j2\pi (i-1)/p}=0$ holds if and only if for every ${\alpha }_i=\alpha$ ($i=1,2,\cdots p$), α is a constant.

Next, we prove the Theorem 1 via Lemma 1.

Proof. 

Take any $\kappa \in kerH\cap {\tilde{\mathcal{X}}}^n$. There must exist ${\mathbf{x}}^{\prime },{\mathbf{x}}^{″}\in {\mathcal{X}}^n$ such that $\kappa ={\mathbf{x}}^{\prime }-{\mathbf{x}}^{″}$ as $\kappa \in {\tilde{\mathcal{X}}}^n$. With the definition of $kerH$, then we have $H\kappa =H({\mathbf{x}}^{\prime }-{\mathbf{x}}^{″})=\mathbf{0}$, i.e., ${\mathbf{h}}_l({\mathbf{x}}^{\prime }-{\mathbf{x}}^{″})=0$ ($1⩽l⩽m$). From the construction as in (5), we have

$$\sum _{i\in \mathcal{N}\left(l\right)}{\alpha }_i{e}^{j2\pi (i-1)/p}+\sum _{i\notin \mathcal{N}\left(l\right)}0·e^{j2\pi (i-1)/p}=0,(1⩽i⩽p),$$

(6)

where ${\alpha }_i=x_i^{\prime }-x_i^{″}$ ($i\in \mathcal{N}\left(l\right)$) is an integer. From Lemma 1, the Equation (6) holds if and only if ${\alpha }_i=0$, i.e., $x_i^{\prime }=x_i^{″}$ for all $i\in \mathcal{N}\left(l\right)$. As ${\displaystyle \bigcup _{l=1}^m}\mathcal{N}\left(l\right)=\{1,2,\cdots ,n\}$, we have ${\mathbf{x}}^{\prime }={\mathbf{x}}^{″}$. Thus $\kappa ={\mathbf{x}}^{\prime }-{\mathbf{x}}^{″}=\mathbf{0}$, this implies $kerH\cap {\tilde{\mathcal{X}}}^n=\left\{\mathbf{0}\right\}$.    □

4.3. Integer Sum-Peeling Algorithm for Event Detection

The number of nonzero variable nodes contained in a measurement is called the measurement degree $\eta$ and denotes ${\mathcal{X}}^{*}=\mathcal{X}\backslash 0$. Then, the variable nodes connected to the measurement with $\eta =D$ ($D=0,1$) can be verified through the following rules.

R1. If ${∥y_i∥}^2=0$, then all the variable nodes connected to $y_i$ are verified as having a zero value.

R2. If ${∥y_i∥}^2={∥{\chi }_j∥}^2$ and $l=(\angle {\chi }_j{y}_i/2\pi )p$ is an integer, where ${\chi }_j\in {\mathcal{X}}^{*},1⩽j⩽q-1$, then the variable node l can be verified with ${\chi }_j$, and all the other variable nodes connected to $y_i$ are verified with zero values.

Furthermore, for the nonzero measurement with degree $\eta ⩾D$ ($D⩾2$), the variable nodes connected to it are verified by the enumeration method.

R3. If $y_i={\mathsf{\Lambda }}_l{\mathbf{f}}_{\left\{\mathcal{N}\right(i\left)\right\}}^{{}^{\prime }}$, where ${\mathsf{\Lambda }}_l$ is a sparse integer vector of dimension $\left|\mathcal{N}\left(i\right)\right|$ with greater than 1 but less than D different nonzero elements ${\chi }_j$ (${\chi }_j\in {\mathcal{X}}^{*},1⩽j⩽q-1$), then all the variable nodes connected to $y_i$ are verified as ${\mathsf{\Lambda }}_l$.

R1–R3 can be performed since the construction (5) guarantees unique solution. The parameter D is called as selective degree. Then, we propose a peeling algorithm called the integer sum-peeling (ISP) algorithm, which is presented in Algorithm 1.

Algorithm 1 Integer sum-peeling-algorithm

Input: observation vector $\mathbf{y}$, the measurement matrix H, the selective degree D, constant prime p.

(1) If ${∥y_i∥}^2=0$ for $1⩽i⩽m$, verify: ${\widehat{x}}_{\left\{\mathcal{N}\right(i\left)\right\}}=0$.

(2) If ${∥y_i∥}^2={∥{\chi }_j∥}^2$ and $l=(\angle {\chi }_j{y}_i/2\pi )p$ is an integer for $1⩽i⩽m$ (${\chi }_j\in {\mathcal{X}}^{*},1⩽j⩽q-1$). Verify: ${\widehat{x}}_l={\chi }_j$, ${\widehat{x}}_{\left\{\mathcal{N}\right(i)\backslash l\}}=0$.

(3) If $0<{∥y_i∥}^2\ne {∥{\chi }_j∥}^2$ for $1⩽i⩽m$, ${\chi }_j\in {\mathcal{X}}^{*},1⩽j⩽q-1$ and $D>1$, set $\tilde{\mathbf{f}}={\left[f_{\left\{\mathcal{N}\right(i\left)\right\}}\right]}^{{}^{\prime }}$, $\overline{\rho }=\left|\mathcal{N}\left(i\right)\right|$. Construct matrix $\mathsf{\Lambda }$, its rows consist of all sparse integer vectors of dimension $\overline{\rho }$ with greater than 1 but less than D different nonzero elements ${\chi }_j$. Compute the vector: $\zeta =\mathsf{\Lambda }\tilde{\mathbf{f}}$. Go to step 4).

(4) If $\exists l\mathrm{s}.\mathrm{t}{\zeta }_l=y_i$, verify: ${\widehat{x}}_{\left\{\mathcal{N}\right(i\left)\right\}}={\mathsf{\Lambda }}_l$.

(5) Peel off: remove all the edges connected to verified variable nodes ${\widehat{x}}_{\left\{\mathcal{N}\right(i\left)\right\}}$, $\mathbf{y}=\mathbf{y}-H\widehat{\mathbf{x}}$.

(6) Repeat step (1)–(5) until all the variable nodes are verified.

output: the recovered sparse integer-valued signal $\widehat{\mathbf{x}}$.

5. Performance Analysis of Integer Sum-Peeling Algorithm

This section elaborates on the overall performance of the ISP algorithm using density evolution, which converges to the performance of the tree-like neighborhood $G_v^{2\ell }$ as n tends to infinity [26,27,28,29]. $G_v^{2\ell }$ is defined as the subgraph containing the variable node v and all those nodes that are incident to v with any path of length less than or equal to $2\ell$.

Definition 4.

A stopping set $\mathcal{S}$ is a subset of the set of variable nodes $\mathcal{V}$, by which all neighbors of $\mathcal{S}$ are connected to $\mathcal{S}$ at least twice.

5.1. Asymptotic Analysis of Integer Sum-Peeling Algorithm

In the following, we provide a definition of the asymptotic analysis, highlighting the technical components.

Density evolution: We analyze the performance of our proposed ISP algorithm over a typical graph (i.e., cycle-free) of the ensemble for a fixed number of peeling iterations i. We assume that a local neighborhood of every edge in the graph is cycle-free (tree-like), and derive a recursive equation that represents the average density of remaining edges in the pruned graph at iteration.

In this paper, the bipartite graphs are constructed randomly with $\lambda \left(x\right)=x^{d-1}$, i.e., every variable node is connected to d check nodes, one uniformly random check node in each of the d sets. To analyze the performance of the peeling decoder performed on a tree-like graph, we need to determine another degree distribution $\rho \left(x\right)={\sum }_j{\rho }_j{x}^{j-1}$, i.e., ${\rho }_j$. According to the ensemble of left d-regular bipartite graph, the degree of a check node is a binomial $B(d/m,n)$ and can be well approximated by a Poisson random variable

$${\rho }_j\approx \frac{{(d/\beta )}^j{e}^{-d/\beta }}{j!},$$

(7)

where $\beta =m/n$ is the sampling ratio.

With the tree-like neighborhood, the ISP procedures over different nodes in the first l iterations are independent. The ISP algorithm can decode up to D nonzero variable nodes, which can be verified by the $(l+1)$-th iteration if the check node $D-1$ are connected at most. Let $p_l$ be the expected rate of unverified nonzero variable nodes at l-th iteration ($p_0=k/n$), then, the probability $p_{l+1}$ can be written with regard to the probability $p_l$ at the l-th iteration in a recursive manner:

$$p_{l+1}=p_0{(1-{\displaystyle \sum _{i=0}^{D-1}}\sum _j{\rho }_j\left(\begin{array}{c}j-1\\ i\end{array}\right)p_l^i{(1-p_l)}^{j-1-i})}^{d-1}.$$

(8)

More specifically, in this paper we only consider $D=1$, and 2. When $D=1$, the term ${\displaystyle \sum _j}{\rho }_j{(1-p_l)}^{j-1}$ in (8) can be approximated by $e^x$ of Taylor expansion

$$\rho \left(x\right)=\sum _j{\rho }_j{x}^{j-1}=e^{-(1-x)\frac{d}{\beta }}/x.$$

(9)

Therefore, the density evolution Equation (8) can be obtained as

$$p_{l+1}=p_0{(1-\frac{e^{-\frac{d}{\beta }{p}_l}}{1-p_l})}^{d-1}.$$

(10)

Similarly, when $D=2$, the density evolution equation can be given by

$$p_{l+1}\approx p_0{(1-\frac{e^{-\frac{d}{\beta }{p}_l}}{1-p_l}-p_l\frac{e^{-\frac{d}{\beta }{p}_l}}{1-p_l}\frac{d}{\beta })}^{d-1}.$$

(11)

Table 1. Success thresholds of ISP for different $(d,\beta )$.

$(\mathit{d},\mathit{\beta })$	(3, 0.1)	(3, 0.2)	(4, 0.1)	(4, 0.2)	(6, 0.1)	(6, 0.2)
$D=1$	$0.0846$	$0.1758$	$0.0792$	$0.1629$	$0.0647$	$0.1319$
$D=2$	$0.1627$	$0.3444$	$0.1378$	$0.2867$	$0.1043$	$0.2136$

lists the analytical success thresholds of the ISP algorithm for measurement matrix with different d, $\beta$ and D. As can be seen, the success thresholds improve with increased D. Furthermore, when fixing the sampling ratio $\beta$, as shown in Table 1, the overall performance of the ISP algorithm is improved with decreased d.

Our next set of results investigate the degree of agreement between simulation results of ISP algorithm and asymptotic analysis, the plots in Figure 2 and Figure 3 correspond to the evolution of $p_l$ with iterations l for the ISP algorithm over the $(d=3,\beta =0.2)$. When $D=1$ and $(d=3,\beta =0.2)$, the success threshold is 0.1758. It can be observed that the case of $k/n=0.1$ (below the success threshold) tends to 0 for smaller values of l compared with $k/n=0.17$ (near the success threshold), while the in the case of $k/n=0.2$ (above the success threshold) no more tend to 0. The simulation results of $D=2$ are also very similar to $D=1$, as shown in Figure 3. We observe that the two sets of results are in close agreement, particularly with the asymptotic analysis.

Notably, the above analysis is based on the assumption of a tree-like neighborhood. This is true when n, k goes to infinite. The concentration results and convergence to a tree-like case have been investigated widely in channel coding and CS [26,30], and our results in this regard are also consistent with [30], so, this content is omitted due to the limited space.

5.2. Finite Length Analysis of Integer Sum-Peeling Algorithm

This section evaluates the performance of an ISP algorithm with finite n. This is followed by a stopping set analysis of the decoding algorithm in binary erasure channel (BEC), but with some differences. In each iteration, the ISP algorithm can verify up to D nonzero variable nodes from a check node, while the traditional peeling algorithm can only decode, at most, one erasure in BEC. In order to exploit the similarity between the ISP algorithm and the traditional algorithm used on BEC, we expand Definition 4 to a generalized stopping sets.

Definition 5

(D-stopping set).A D-stopping set ${\mathcal{S}}_{\mathcal{D}}$ is a subset of the set of variable nodes $\mathcal{V}$ such that all neighbors of ${\mathcal{S}}_{\mathcal{D}}$ are connected to ${\mathcal{S}}_{\mathcal{D}}$ at least $D+1$ times.

The next lemma shows the key role that D-stopping set play in the ISP algorithm.

Lemma 2.

Let regular $(\lambda ,\rho )$-H constructed in (5) be a measurement matrix. Let $\mathcal{T}$ denote the set of nonzero coefficients of sparse binary signal. Then the set of nonzero variable nodes which remains when the sum-peeling algorithm stops is equal to the unique maximal D-stopping set of $\mathcal{T}$.

Proof. 

Let ${\mathcal{S}}_{\mathcal{D}}$ be a D-stopping set included in $\mathcal{T}$. Consider a special case when all other coefficients are known, every neighbor of ${\mathcal{S}}_{\mathcal{D}}$ has at least $D+1$ connections to the set ${\mathcal{S}}_{\mathcal{D}}$ so that the ISP algorithm can not verify the nonzero variable nodes included in the unique maximal stopping set contained in $\mathcal{T}$. Conversely, if the ISP algorithm stops at a set ${\mathcal{S}}_{\mathcal{D}}$, then this happens only if all neighbors of ${\mathcal{S}}_{\mathcal{D}}$ have at least $D+1$ connections to ${\mathcal{S}}_{\mathcal{D}}$. Additionally, since zero variable nodes included in a D-stopping set can be verified by the ISP algorithm, ${\mathcal{S}}_{\mathcal{D}}$ must be maximal D-stopping set. □

Lemma 2 gives a foundation to implement the theoretical analysis and exploit the similar ensemble of LDPC results in BEC [31]. In [31], the authors developed combinatorial approaches to compute recursively the exact average bit erasure probability performance of the LDPC codes. Following these combinatorial approaches, the average unverified variable node probability (equivalent to bit erasure probability in BEC) can be calculated exactly. In the simulation results, we show the average verified nonzero variable node probability as a function of density factor $\alpha$ for finite n.

5.3. The Number of Measurements and Computational Complexity of Integer Sum Peeling Algorithm

The number of measurements: The ISP architecture (see Definition 2 (measurement matrix) in Section 3) with d stages, has d distinct measurement patterns, chosen as per the discussions in Section 3 and Section 4. These constructions are deterministic and are pre-computed. We assume that there is random access memory, and the unit cost of each I/O operation is used to read measurements. As shown in Section 4.1, we have three different ISP architectures, with $d=3$, $d=4$ and $d=6$ regions, for different D. The total measurements used for these regions are $m=1.182k$, $m=1.2626k$, and $m=1.5456k$, respectively, for $D=1$ and $\beta =0.1$. In general, for any fixed d and D, the number of measurements m can be as small as $\mathcal{O}\left(k\right)$.

It can be easily concluded that the proposed ISP requires less measurements than the existing method [14,19], which the number of required measurements is of $\mathcal{O}(-nlog(1-k/n\left)\right)$ and $\mathcal{O}\left(klog\right(n\left)\right)$. We also verify the measurement dimension required by these methods in simulations.

The computational complexity: In the proposed recovery algorithm, the maximum value of D is only considered to be 2. As shown in [24], the arithmetic operation is of $\mathcal{O}\left(k\right)$ for traditional CS. When D is set to 1, the main difference between ISP and traditional CS [24] is the rule R2, where the ISP algorithm requires extra $q-1$ comparisons. Thus, the recovery complexity is of $\mathcal{O}\left(k\right(q-1\left)\right)$.

It also can be easily concluded that the proposed ISP requires less iterations than the existing method [14,19], which the number of required iterations is of $\mathcal{O}(-nlog(1-k/n\left)\right)$ and $\mathcal{O}\left(klog\right(n\left)\right)$.

6. Noisy Measurements

We consider the following model of measurements contaminated with noise:

$$\mathbf{y}=H\mathbf{x}+\mathbf{n},$$

(12)

where the measurements $\mathbf{y}$ of (1) were corrupted by an additive noise vector $\mathbf{n}$. The noise vector to the measurements results in the probability of having a 0 or integer amplitude of measurement to be zero. This will disable the rules R1, R2 and R3 in verifying the variable nodes. However, the rules can be effective by slight refinements.

We firstly show how to generalize the measurement matrix H of (5) in the noisy case. Following with (5), the $m\times n$ measurement matrix is given by

$$H=\left[\begin{array}{c}{\tilde{\mathbf{h}}}_1\otimes F\\ ⋮\\ {\tilde{\mathbf{h}}}_{m^{\prime }}\otimes F\end{array}\right],$$

(13)

where the $T\times n$ matrix F is

$$F=\left[\begin{array}{cccc}1& \cdots & 1& \cdots \\ 1& \cdots & W^{i-1}& \cdots \\ ⋮& ⋮& ⋮& ⋮\\ 1& \cdots & W^{(i-1)(T-1)}& \cdots \end{array}\right]\left[\begin{array}{cccc}{g}_1& 0& \cdots & 0\\ 0& g_2& \cdots & 0\\ ⋮& ⋮& \ddots & ⋮\\ 0& \cdots & 0& g_n\end{array}\right],$$

$m=T{m}^{\prime }$, $W=e^{-j2\pi /p}$ ($p⩾n$ is a prime), ${\tilde{\mathbf{h}}}_i$ be the i-th row of the $m^{\prime }\times n$ local matrix $\tilde{H}$ and the weight entry $g_i$ is from i.i.d Gaussian distribution. The main difference between the construction of (5) and (13) is single vector $\mathbf{f}$ to matrix F, this results in single measurement $y_i$ to T measurements $y_i,\cdots ,y_{i+T-1}$ (denotes as ${\mathbf{y}}_T$ vector). Next, we exploit a similar rule of a noiseless case based on ${\mathbf{y}}_T$.

R4. If ${∥{\mathbf{y}}_T-F_{\left\{\mathcal{N}\right(i\left)\right\}}{\mathsf{\Lambda }}_l∥}^2⩽(1+\epsilon ){\sigma }^2$, where $F_{\left\{\mathcal{N}\right(i\left)\right\}}$ is taken from the columns of matrix F with support set $\mathcal{N}\left(i\right)$, ${\mathsf{\Lambda }}_l$ is a binary vector of dimension $\left|\mathcal{N}\left(i\right)\right|$ with at most D ones, ${\sigma }^2$ is variance of noise vector and $\epsilon$ is a parameter between 0 and 1. Then, all the variable nodes connected to ${\mathbf{y}}_T$ are verified as ${\mathsf{\Lambda }}_l$.

Similarly, the rule R4 is responsible for verifying the variable nodes via the peeling–decoding algorithm. Therefore, the reconstruction algorithm in a noisy case is essentially identical with the noiseless case, i.e., the ISP algorithm. We will show the validity of the ISP algorithm with R4 in the next section.

7. Simulation Results

In this section, we evaluate the performance of ISP and conventional sparse event detection algorithms through numerical simulations. We also show the degree of agreement between the asymptotic analysis and simulation results. In all simulations, the left d-regular bipartite graph $G(d,\beta )$ ($\beta =m/n$) is constructed randomly.

Firstly, we compare the proposed ISP algorithm with conventional basis pursuit (BP) algorithm in CS [1] and the sum of absolution values (SAV) algorithm [17]. Three event sources cases of $\mathcal{X}$ are considered (same with [17]): ${\mathcal{X}}_1=\{0,1\},\mathbb{P}\left(0\right)=Pr,\mathbb{P}\left(1\right)=1-Pr$; ${\mathcal{X}}_2=\{-1,0,1\},\mathbb{P}\left(0\right)=Pr,\mathbb{P}\left(1\right)=\mathbb{P}(-1)=(1-Pr)/2$; ${\mathcal{X}}_3=\{-2,-1,0,1,2\},\mathbb{P}\left(0\right)=Pr,\mathbb{P}(-2)=\mathbb{P}(-1)=\mathbb{P}\left(1\right)=\mathbb{P}\left(2\right)=(1-Pr)/4$. In [17], the author considers the finite alphabet set $\mathcal{X}$ that does not necessarily contain 0, i.e., $0⩽Pr⩽1$. In this paper, we only consider the sparse integer-valued signal with high Pr. In the SAV and BP algorithms, the simulations are based on randomly generated measurement matrix $H\in {\mathbb{R}}^{200\times 1000}$ whose entries are chosen independently from standard Gaussian distribution. In the proposed ISP algorithm, the measurement matrix $H\in {\mathbb{C}}^{100\times 1000}$ is adopted as constructed in (5) with the bipartite graph $G(3,0.1)$.

Figure 4 illustrates the averaged NSR (noise-to-signal ratio) ${∥\mathbf{x}-\widehat{\mathbf{x}}∥}_2/{∥\mathbf{x}∥}_2$ as a function of the probability Pr of zero elements in $\mathcal{X}$. Note that the lower critical probability Pr implies a better recovery performance. As shown in the figure, the critical probability Pr of the proposed ISP algorithm ($D=1$ and $D=2$) is lower than the BP and SAV algorithms for all cases of $\mathcal{X}$. Furthermore, the performance of the proposed ISP algorithm is independent of the number of symbols q, while the BP and SAV algorithms have worse performance, with decreased q.

Secondly, we show the number of measurements (the number of sensors) required to exactly detect the sparse events versus the sparsity order. Each nonzero element of $\mathbf{x}$ is randomly chosen from the event sources set ${\mathcal{X}}^{*}=\{+1,-1\}$. The support of $\mathbf{x}$ (the position of active events) is chosen randomly, $d=3$ is adopted, the $n={10}^4$ event sources are randomly distributed in an area of 1000 m by 1000 m, and the propagation loss factor is 3. As shown in Figure 5, the number of sensors of the proposed ISP method is significantly lower than that for the asymptotic bound of the WSC method [7] and standard CS ($D=1$ and $D=2$). In addition, as see in the figure, the simulation results are close with the asymptotic threshold.

Thirdly, we apply the ISP algorithm to six randomly constructed left d-regular bipartite graphs $G(d=6,\beta =0.05)$ with event sources $n=3\times {10}^3,{10}^4,{10}^5$ to investigate the agreement between our asymptotic analysis and simulation results. Each nonzero element of $\mathbf{x}$ is randomly chosen from the set ${\mathcal{X}}^{*}=\{+1,-1\}$. Let $p_0$ denote the maximum sparsity order for the signal of length n, to be exactly recovered by the proposed ISP algorithm. The exact recovery of thresholds $p_0$ are listed in

Table 2. Asymptotic and simulation success thresholds for ISP.

D	$3\times {10}^3$	$1\times {10}^4$	$1\times {10}^5$	Asymptotic
1	$p_0=0.0013$	$p_0=0.0023$	$p_0=0.003$	$p_0=0.0031$
2	$p_0=0.0027$	$p_0=0.0038$	$p_0=0.0047$	$p_0=0.0051$

. As can be seen, for all graphs, the larger n indicates higher closeness between the thresholds $p_0$ and the asymptotic threshold. Accordingly, the simulation results match well with the theoretical results.

Fourthly, we compare the performance of the ISP algorithm with that of existing binary event detection algorithms considering binary event detection, a special class of event sources.

(1)

Consider that the $n=500$ event sources are randomly distributed in an area of 500 m by 500 m, the propagation loss factor is 3 and the sparsity k is set to 100. The optimal row weights of the sparse matrix corresponding to AFCS are set, respectively, when $D=1$, $L=7$, and when $D=2$, $L=9$. ISP and BCS also employ the sparse matrices of the AFCS scheme for a fair comparison. Figure 6 shows the reconstruction error rate performance curves of the ISP algorithm and the two existing reconstruction algorithms of AFCS and BCS with the measurement dimension varying. The reconstruction error rate is defined as the ratio of the number of nonzero signals that were not successfully reconstructed to the signal dimension. From Figure 6, it can be observed that the performance of the proposed ISP algorithm is basically the same as that of the AFCS algorithm; however, previous analysis reveals the lower complexity of the ISP algorithm compared with the AFCS algorithm. On the other hand, it can also be observed that both the ISP and AFCS reconstruction algorithms outperform the BCS scheme.

(2)

In the AFCS algorithm, the optimal row weight of the sparse matrix is $L=⌈-0.5(D+2)/log(1-k/n)⌉$; however, the AFCS scheme generally cannot optimize the row weight of its measurement matrix because of the actual unknown or variable sparsity. In this experiment, we fix the row weight of the sparse matrix, and compare the performance of the ISP and AFCS algorithms. Consider two experimental situations, $L=40$, event sources $n=1000$ and $L=120$, event sources $n=2000$. Figure 7 reveals the better performance of the ISP algorithm compared with the AFCS algorithm, for a fixed row weight, which suggests that the ISP scheme is robust to sparsity varying. In addition, it can also be observed that there is a broken line in AFCS. This is because the AFCS constructs the measurement matrix adaptively, and when the row weight is not optimal, there may be no solution.

(3)

The theoretical performance of the above three event detection algorithms is also compared. In the simulation, event sources $n={10}^5$ are randomly distributed in an area of 1000 m by 1000 m, the propagation loss factor is 3. The measurement matrix is a randomly generated left-regular sparse matrix, where the column weight is $d=3$. According to [14], it can be observed that the measurement dimension required by AFCS to accurately reconstruct sparse binary signals is $\mathcal{O}(-nlog(1-k/n\left)\right)$, which is smaller than $\mathcal{O}(klog(n\left)\right)$ that required by BCS. Figure 8 demonstrates the lower sampling rate required for accurate reconstruction of the ISP algorithm proposed in this paper compared with the BCS and AFCS schemes when $D=2$, and the performance of the ISP algorithm and AFCS algorithm are basically identical when $D=1$. Furthermore, it can be found that the simulation results of the ISP reconstruction algorithm are basically consistent with the theoretical results.

Finally, we show the validity and performance of the ISP algorithm in a noisy environment. The binary sparse event sources are adopted for ease of comparison. The signal-to-noise ratio (SNR) is defined as:

$$\mathrm{SNR}=10{log}_{10}\frac{{∥\mathbf{Hx}∥}^2}{{∥\mathbf{n}∥}^2}\mathrm{dB},$$

(14)

Figure 9 illustrates the MSE performance of the ISP and binary ${\ell }_1$ reconstruction algorithms as a function of SNR. For the binary ${\ell }_1$ reconstruction algorithm, a standard Gaussian random matrix is taken, and for the ISP algorithm, the rows of the sparse matrix are reset to 3, $T=4$. In all simulation experiments, event sources $n={10}^3$ are randomly distributed in an area of 500 m by 500 m, the propagation loss factor is 3, the matrix measurement dimension is $100\times 1000$, and the sparsity is set to $k=20$. According to the figure, it can be observed that the MSE performance of the ISP algorithm is better than that of the event detection algorithm when $D=2$. This also means that the ISP algorithm is also effective in noisy environments.

8. Conclusions

In this paper, the event-detection problem is modeled as the decoding of sparse graph code, and the problem in the IoT system is described from the perspective of coding theory. Using compressive sensing, the high-dimensional event sources are recovered from incomplete linear measurements. A simple deterministic sparse measurement matrix was adopted to uniquely determine the event sources, based on which an integer sum-peeling recovery algorithm was proposed to exploit the structure of event detection. To corroborate the performance of the recovery algorithm, the asymptotic analysis was provided via the density evolution, which was verified by simulation. Simulation results also showed that the event detection algorithm had superior performance compared with other existing algorithms.