- Research
- Open Access

# Blind distributed estimation algorithms for adaptive networks

- Muhammad O Bin Saeed
^{1}, - Azzedine Zerguine
^{1}Email author and - Salam A Zummo
^{1}

**2014**:136

https://doi.org/10.1186/1687-6180-2014-136

© Bin Saeed et al.; licensee Springer. 2014

**Received:**16 July 2014**Accepted:**19 July 2014**Published:**1 September 2014

## Abstract

Until recently, a lot of work has been done to develop algorithms that utilize the distributed structure of an ad hoc wireless sensor network to estimate a certain parameter of interest. However, all these algorithms assume that the input regressor data is available to the sensors, but this data is not always available to the sensors. In such cases, blind estimation of the required parameter is needed. This work formulates two newly developed blind block-recursive algorithms based on singular value decomposition (SVD) and Cholesky factorization-based techniques. These adaptive algorithms are then used for blind estimation in a wireless sensor network using diffusion of data among cooperative sensors. Simulation results show that the performance greatly improves over the case where no cooperation among sensors is involved.

## Keywords

- Blind estimation
- Diffusion
- Adaptive networks

## 1 Introduction

*N*sensor nodes spread over a geographic area as shown in Figure 1. Sensor measurements are taken at each node at every time instant. The objective of the sensor is to estimate a certain unknown parameter of interest using these sensed measurements.

Several algorithms have been devised in the literature for distributed estimation [1–5]. The work in [1] introduces a distributed estimation approach using the recursive least squares algorithm. Other algorithms involving the least-mean-square (LMS) approach have also been suggested [2–5].

However, all these algorithms assume that the input regressor data, **u**_{k,i}, is available at the sensors. If this information is not available, then the said problem becomes a blind estimation problem. Blind algorithms have been a topic of interest ever since Sato devised a blind algorithm [6] in the context of equalization [7]. Since then, several algorithms have been derived for blind estimation [8–15]. The work in [8] summarizes the second-order statistics-based approaches for blind identification. These include multichannel as well as single-channel blind estimation methods such as the works in [9] and [10]. The work in [11] is one of the most cited blind estimation techniques for a single-input-single-output (SISO) model. However, unlike in [11], it is shown in [12] that the technique of [11] can be improved upon using only two blocks of data. A key idea in [12] is used in [13] to devise an algorithm that does indeed show improvement over the algorithm of [11]. However, the computational complexity of this new algorithm (in [13]) is very demanding. A generalized algorithm is devised in [14], improving upon both algorithms developed in [12, 13]. In [15], a Cholesky factorization-based least squares solution is suggested that simplifies the work of [11, 13, 14]. Although the performance of the algorithm developed in [15] is not as good as that of the previous algorithms, it nevertheless provides an excellent trade-off between performance level and computational complexity. However, in systems where less complexity is required and performance can be compromised to some extent, this algorithm would provide a good substitute to the algorithms developed in [12, 13].

As mentioned above, for the case where the input regressor data is not available to the WSN environment used, then blind estimation techniques become mandatory. In this case, since blind estimation techniques have not yet been developed for this field, blind block-recursive least squares algorithms would have to be devised, inspired from the works in [11] and [15], and then implemented in a distributed WSN environment using the diffusion approach suggested in [1].

The following notation has been used here. Boldface letters are used for vectors/matrices and normal font for scalar quantities. Matrices are defined by capital letters and small letters are used for vectors. The notation (.)^{
T
} stands for transposition for vectors and matrices and expectation operation is denoted by *E*[.]. Any other mathematical operators used in this paper will be defined as and when introduced in the paper.

The paper is divided as follows: Section 2 defines the problem statement. Section 3 gives a brief overview of the blind estimation algorithms taken into consideration in this work. Section 4 proposes the newly developed recursive forms of the two algorithms, as well as their diffusion counterparts, to be used in wireless sensor networks. Section 5 studies the computational complexity of all the algorithms. The simulation results are discussed in detail in section 6. Finally, the paper is concluded in section 7.

## 2 Problem statement

*K*sensor nodes deployed over a geographical area, to estimate an (

*M*×1) unknown parameter vector

**w**

^{ o }as shown in Figure 1. Each node

*k*has access to a time realization of a scalar measurement

*d*

_{ k }(

*i*) that is given by

where **u**_{k,i} is a (1×*M*) input regressor vector, *v*_{
k
} is a spatially uncorrelated zero-mean additive white Gaussian noise with variance ${\sigma}_{{v}_{k}}^{2}$ and *i* denotes the time index. The input data is assumed to be Gaussian. The aim of this work is to estimate the unknown vector **w**^{
o
} using the sensed data *d*_{
k
}(*i*) without knowledge of the input regressor vector. The estimate of the unknown vector can be denoted by an (*M*×1) vector **w**_{k,i}. Assuming that each node *k* cooperates only with its neighbors and *k* has access to updates **w**_{l,i}, from its ${\mathcal{K}}_{k}$ neighboring nodes at every time instant *i*, where $\left\{l\in {\mathcal{K}}_{k},l\ne k\right\}$, in addition to its own estimate, **w**_{k,i}. The adapt-then-combine (ATC) diffusion scheme [16] first updates the local estimate at each node using the adaptive algorithm and then fuses together the estimates from the ${\mathcal{K}}_{k}$ neighboring nodes. This scheme will be used in this work for the development of our distributed algorithm. Note that, even though this work is designed for a fixed topology, it can be extended to a dynamic one.

## 3 Blind estimation algorithm

In this work, the input regressor data, **u**_{
k
}(*i*) is assumed to be not available to the sensors and the unknown vector **w**^{
o
} is estimated using only the sensed values, *d*_{
k
}(*i*). Since the data considered here is Gaussian, a method using second-order statistics only is sufficient for such an estimation problem as it will capture all the required data statistics. Even for the case of non-Gaussian data, such an approach would provide a suboptimal yet accurate enough estimate. The work in [11] uses the second-order statistics in an intelligent manner to create a null space with respect to the unknown vector **w**^{
o
}. At the receiver end, this null space is then exploited to estimate the unknown vector. The authors in [15] further simplify the algorithm of [11] by proposing a new algorithm that reduces complexity but at a cost of performance degradation. These two algorithms are taken into consideration in this work as one provides excellent results whereas the other provides a computationally tractable solution.

### 3.1 Singular value decomposition-based blind algorithm

*M*×1). Suppose the input vector is a (

*P*×1) vector with (

*P*−

*M*) trailing zeros

*P*and

*M*are related through

*P*= 2

*M*−1. The unknown parameter vector can be written in the form of a convolution matrix given by

**w**

^{ o }=[

**w**(

**0**),

**w**(

**1**),…,

**w**(

**M**−

**1**)] is the unknown parameter vector. The output data block can now be written as

**d**

_{ k }(

*i*) is the ((2

*M*−1)×1) output data block and

**v**

_{ k }is the added noise. The output blocks {

**d**

_{ k }(

*i*)} are collected together to form the following matrix

*N*is greater than the minimum number of data blocks required for the input blocks to have a full rank. The singular value decomposition (SVD) of the autocorrelation of

**D**

_{k, N}gives a set of null eigenvalues. Thus, the eigendecomposition

*P*×

*M*) matrix of eigenvectors and ${\stackrel{~}{\mathbf{\text{U}}}}_{k}$ is a (

*P*× (

*M*−1)) matrix whose columns form the null space for

**D**

_{k, N}. This implies

*m*= 1,…,

*M*−1 and ${\stackrel{~}{\mathbf{u}}}_{k,m}$ is simply the

*m*

_{th}vector of ${\stackrel{~}{\mathbf{\text{U}}}}_{k}$. This equation denotes convolution since, as pointed earlier,

**W**is essentially a convolution matrix. Since convolution is a commutative operation, Equation 8 can also be written as

**w**is a component vector of the convolution matrix

**W**and ${\mathcal{U}}_{k,\phantom{\rule{0.3em}{0ex}}m}$ is an (

*M*×

*M*) Hankel matrix given by

The final parameter estimate is given by the unique solution (up to a constant factor) of Equation 9. It is important to note here that due to the presence of noise, the final estimate is not accurate.

### 3.2 Cholesky factorization-based blind algorithm

**D**

_{k,N}and assuming the input data regressors to be white Gaussian with variance

*σ*

**s**,

*k*2, we get

However, this information, particularly the information about the input regressor data, is not always known and cannot be easily estimated either. Therefore, the correlation matrix of the unknown parameter vector has to be approximated by the correlation matrix of the received/sensed data. Now the algorithm in [15] uses the Cholesky factor of this correlation matrix to provide a least squares estimate of the unknown parameter vector.

*K*blocks of data. So the correlation matrix is given by

*vec*operator to get an (

*M*

^{2}× 1) vector ${\widehat{\mathbf{\text{G}}}}_{k}$

**g**and

**w**

^{ o }are related through

**Q**is an (

*M*

^{2}×

*M*) selection matrix given by $\mathbf{\text{Q}}={\left[{\mathbf{\text{J}}}_{1}^{T}{\mathbf{\text{J}}}_{2}^{T}\dots {\mathbf{\text{J}}}_{M}^{T}\right]}^{T}$, and the (

*M*×

*M*) matrices

**J**

_{ q }are defined as

*a*,

*b*,

*c*} = 0,…,

*M*−1. So the least squares estimate of the unknown parameter vector is given by [15]

The work in [15] also gives a method for estimating the noise variance that is on the whole adequate except it may not provide correct estimates of the noise variance at low SNRs. As a result, subtracting the estimated variance from the autocorrelation matrix may not yield a positive-definite matrix. In such cases, the use of Cholesky factorization may not be justified. However, neglecting the noise variance estimate altogether may lead to a poor estimate of the parameter vector. Despite this shortcoming, the main advantage of this method remains its very low computational complexity. Whereas the method of [11] requires the singular value decomposition of the autocorrelation matrix followed by the building of Hankel matrices using the null eigenvectors and then finding a unique solution to an over-determined set of linear equation, this method [15] simply evaluates the Cholesky factor (upper triangular matrix) of the autocorrelation matrix and then uses it to directly find the required estimate. Computational complexity is, thus, greatly reduced but at the cost of a performance degradation.

Both of the above-mentioned methods require several blocks of data to be stored before estimation can be performed. Although the least squares approximation gives a good estimate, a sensor network requires an algorithm that can be deployed in a distributed manner, which is possible only with recursive algorithms. Therefore, the first step would be to make both algorithms in [11] and [15] recursive in order to utilize them in a WSN setup.

## 4 Proposed recursive blind estimation algorithms

In the ensuing, the previously mentioned blind estimation algorithms are made recursive and applied over a wireless sensor network.

### 4.1 Blind block recursive SVD algorithm

**D**

_{ k }, we have the block data vector

**d**

_{ k }. The autocorrelation matrix for the first data block is defined in as

**R**

_{d, k}yields the eigenvector matrix

**U**

_{ k }, from which we get the (

*M*−1 ×

*M*) matrix ${\stackrel{~}{\mathbf{\text{U}}}}_{k}$ that forms the null space of the autocorrelation matrix. From ${\stackrel{~}{\mathbf{\text{U}}}}_{k}$, we then form the

*M*Hankel matrices of size (

*M*×

*M*+ 1) each, which are then concatenated to give the matrix ${\mathcal{U}}_{k}\left(i\right)$ from which the estimate ${\stackrel{~}{\mathbf{\text{w}}}}_{k}\left(i\right)$ is finally derived. This sequential derivation process is depicted below in (23):

It can be seen from (23) that the recursive algorithm does not become computationally less complex. However, it does require lesser memory compared to the original algorithm of [11] and the result improves with an increase in the number of data blocks processed. The performance almost matches that of the algorithm of [11].

### 4.2 Blind block recursive Cholesky algorithm

In this section, we show how the algorithm of [15] can be converted into a blind block recursive solution.

**Q**

_{ A }= (

**Q**

^{ T }

**Q**)

^{−1}

**Q**

^{ T }, we have

where ${\lambda}_{k}\left(i\right)=1-\frac{1}{i}$ is a variable forgetting factor.

*M*blocks of data have been received as the data correlation matrix needs to be first positive definite before the Cholesky method can be correctly applied. The second issue involves the variance of the additive noise. In [15], it is shown that if the noise variance can be estimated, the estimate of the unknown vector will improve. However, using the noise variance in the recursive algorithm can make the resulting matrix have zero or negative eigenvalues before a sufficient number of data blocks were processed, thus making the use of Cholesky factorization unjustifiable. However, neglecting the noise variance altogether will lead to a performance degradation of this algorithm even though it will be computationally less complex than the SVD approach. One approach is to estimate the noise variance after a certain number of blocks have been received and then use that value for the remainder of the iterations.

### 4.3 Diffusion blind block recursive algorithms

In a wireless sensor network, a distributed algorithm is required, through which nodes can interact with each other and improve their individual estimates as well as the overall performance of the network. In such a scenario, a recursive algorithm is required. This is one major reason for requiring a recursive blind algorithm. Each node can individually update its estimate and then collaborate with the neighboring nodes to improve that estimate. A comparison of different distributed schemes has shown that the *Adapt-Then-Combine* (ATC) diffusion strategy provides the best performance [16]. Therefore, we also implement our distributed algorithms using the ATC scheme.

*k*denotes the node number,

*N*

_{ k }is the set of neighbors of node

*k*, ${\widehat{\mathbf{\text{h}}}}_{k}$ is the intermediate estimate for node

*k*and

*c*

_{ lk }is the weight connecting node

*k*to its neighboring node $l\in {\mathcal{N}}_{k}$, where ${\mathcal{N}}_{k}$ includes node

*k*, and $\sum {c}_{\mathit{\text{lk}}}=1$.

## 5 Complexity of the recursive algorithms

In order to fully understand the variation in performance of these two algorithms, it is necessary to look at their computational complexity as it will allow us to estimate the loss in performance that would result from a reduction in computational load. We first analyze the complexity of the original algorithms and then deal with that of their recursive versions.

### 5.1 Blind SVD algorithm

*M*and the data block size is

*K*. Since a total number of

*N*data blocks are required for the estimation of the unknown parameter vector, where

*N*≥

*K*, the resulting data matrix will therefore be of size

*K*×

*N*. The data correlation matrix will thus be of size

*K*×

*K*and this function will require

*K*

^{2}(2

*N*−1) calculations (including both multiplications and additions) for its computation. The next step is singular value decomposition (SVD), done using the QR decomposition algorithm. This algorithm requires a total of $\left[\frac{4}{3}{K}^{3}+\frac{3}{2}{K}^{2}+\frac{19}{6}K-6\right]$ calculations. Then the null eigenvectors are separated and each eigenvector is used to form a Hankel matrix with all the Hankel matrices then stacked together to form a matrix of size

*M*× (

*K*−

*M*)(

*M*−1). The unique null vector of this new matrix gives the estimate of the unknown vector. To find this eigenvector requires another $\left[\left(2K+\frac{7}{3}\right){M}^{3}-2{M}^{4}+\left(1-4K\right)\frac{{M}^{2}}{2}+\frac{19}{6}M-6\right]$ calculations. So the overall computational load required for the algorithm can be given as

### 5.2 Blind Cholesky algorithm

*M*and the data block size is

*K*. For computational purposes and for the blind SVD algorithm, the total number of data blocks is taken as

*N*. The correlation process is the same except for the final averaging step which results in an extra division so the total number of calculations becomes

*K*

^{2}(2

*N*−1) + 1. The next step is to estimate the noise variance, which requires an SVD decomposition and therefore an extra number of calculations given by $\left[\frac{4}{3}{K}^{3}+\frac{3}{2}{K}^{2}+\frac{19}{6}K-6\right]$. After the SVD decomposition, only one further division is required to estimate the noise variance. The noise variance is then subtracted from the diagonal of the correlation matrix, resulting in another

*K*calculations. After that, the Cholesky factorization is performed, which requires $\left[\frac{1}{3}\left({M}^{3}+3{M}^{2}+M\right)\right]$ calculations. Finally, the last step is to get the estimate of the unknown vector through the pseudo-inverse of Cholesky-factorized data correlation matrix and this step requires further [

*M*(2

*M*

^{2}−1)] calculations. Thus, the total number of calculations required is given as

### 5.3 Blind block recursive SVD algorithm

*K*

^{2}instead of

*K*

^{2}(2

*N*−1). However, an extra (

*M*+ 2) calculations are required for the final step. The overall number of calculations is thus given as

### 5.4 Blind block recursive Cholesky algorithm

*K*

^{2}+ 2) from the (

*K*

^{2}(2

*N*−1) + 1) calculations required by its non-recursive counterpart. The final step includes an extra (

*K*

^{2}+

*M*+ 2) calculations. Thus, the total number of calculations is now given as

*a priori*, the noise variance can be estimated once only and then this same estimated value can be used in the remaining iterations. The number of calculations, thus, reduces to

### 5.5 Comparison of all algorithms

*M*is fixed to 4, that of

*K*is varied for all algorithms and the value of

*N*is varied between 10 and 20 for the least squares algorithms. The number of calculations for the two recursive algorithms discussed before are shown for one iteration only. Recall that in the second algorithm, i.e. the blind block recursive Cholesky algorithm, the noise variance is calculated only once, after a pre-selected number of iterations have occurred, and then kept constant for the remaining iterations. Tables 1 and 2 below summarize the results.

**Computations for original least squares algorithms under different settings**

M = 4 | N = 10 | N = 10 | N = 20 | N = 20 | N = 20 |
---|---|---|---|---|---|

K = 8 | K = 10 | K = 8 | K = 10 | K = 20 | |

SVD | 2,434 | 4,021 | 3,714 | 6,021 | 28,496 |

Chol | 2,180 | 3,575 | 3,460 | 5,575 | 27,090 |

**Computations for recursive algorithms under different settings**

M = 4 | K = 8 | K = 10 | K = 20 |
---|---|---|---|

RS | 1,352 | 2,327 | 13,702 |

RC | 1,100 | 1,883 | 12,298 |

RCNV | 300 | 372 | 972 |

Table 1 lists the number of computations for the original algorithms, showing that the Cholesky-based method requires fewer computations than the SVD-based method and so the trade-off between performance and complexity is justified. If the number of blocks is small, then the Cholesky-based method may even perform better than the SVD-based method as shown in [15]. Here it is assumed that the exact length of the unknown vector is known. Generally, an upper bound of this value is known and that value is used instead of the exact value, resulting in an increase in computations. This assumption is made for both algorithms here to make their comparative study fair.

Table 2 lists the computations-per-iteration for the recursive versions of these two algorithms. RS and RC give the number of computations for the recursive SVD algorithm and the recursive Cholesky algorithm respectively. RCNV lists the number of computations when the noise variance is estimated only once in the recursive Cholesky algorithm. This shows how the complexity of the algorithm can be reduced by an order of magnitude by adopting an extra implicit assumption regarding the wide-sense stationarity of the noise and hence the constancy of its variance from one iteration to the next. Although the performance does suffer slightly, the gain in the reduction of computational complexity more than compensates for this loss.

It is important to note here that even though the SVD and Cholesky factorization operations are being run at every iteration, there is a significant gain achieved in the calculation of the autocorrelation function. While each batch processing algorithm would require a total of *P*^{2}*N*^{2} multiplications, where (*P* × *N*) is the size of the data block matrix, the recursive algorithms only require *P*^{2}*N* multiplications. Thus, there is a reduction in the number of multiplications by a factor of *N*, which becomes significant when the number of blocks *N* is large.

## 6 Simulations and results

### 6.1 Performance of the SVD and Cholesky algorithms

*M*= 4 in an environment with the two signal-to-noise ratios (SNR) of 10 and 20 dB. The two forgetting factors used are fixed at

*λ*= {0.9,0.99}. The block size is taken as

*K*= 8. The results for both algorithms are shown in Figures 3, 4, 5 and 6, for both diffusion (DRC, DRS) and no cooperation (NRC, NRS) cases. As can be seen from these figures, the Cholesky algorithm does not perform well with the smaller forgetting factor. However, the performance improves appreciably with an increase in the forgetting factor but its speed of convergence decreases significantly as well. However, the one main positive attribute of the Cholesky algorithm remains to be its low computational complexity. For the SVD algorithm, the performance improves slightly with an increase in forgetting factor but at a significant loss of convergence speed. These remarks have prompted us to further analyze the impact of the forgetting factor on the performance on these two algorithms, as discussed next.

### 6.2 Further simulation-based analysis of the effect of forgetting factor

*λ*= {0.9,0.95,0.99} and the results are compared with those of the variable forgetting factor case. The SNR is chosen as 20 dB and the network size is taken to be 20 nodes. Figure 7 shows the results for the Cholesky factorization-based RC algorithm. It is seen that the performance improves as the forgetting factor is increased but the convergence slows down. The algorithm performs best when the forgetting factor is variable. The results for the SVD-based RS algorithm are shown in Figures 8, 9 and 10. Figure 8 shows the results for all three fixed forgetting factors as well as those for its variable one. However, as there is not much difference in performance between the four cases, Figure 8 is then zoomed in to see more clearly the algorithm’s transient and near-steady-state behavior. Figure 9 shows the result of this zooming effect. The speed of convergence is fastest for

*λ*= 0.9 and slowest for

*λ*= 0.99. For the variable forgetting factor (VFF) case, the speed is fast initially but then slows down with time. Figure 10 shows the behavior of the algorithm near steady-state. It is evident that the fixed case of

*λ*= 0.99 would yield the lowest steady-state error whereas the VFF case would take the longest to reach the steady-state. Although the steady-state performance of the variable forgetting factor may be as good as for the case of

*λ*=0.99 or even better, its speed of convergence is too slow.

### 6.3 Performance of the two algorithms using an optimal forgetting factor

### 6.4 Effect of block size

*K*= {5,8,10,15,20} and the SNR is set to 20 dB. These settings are applied to both algorithms separately. Here it is important to note that as the size of the data block increases, the total amount of data required for the same number of blocks also increases. Figures 13 and 14 show the results for the RC algorithm and clearly demonstrate that the algorithm fails badly for

*K*= 5. However, for the remaining block sizes, the algorithm’s performance remains almost unaffected by the block size changes. The convergence speeds are nearly the same (see Figure 13) and the performance at steady-state is similar as well for the remaining block sizes, with only a slight difference (see Figure 14). From Figure 14 it can be inferred that the best result, in every respect, is achieved when the block size is just large enough to achieve a full rank input data matrix (

*K*=8 in this case), as expected. Thus, it is essential to estimate a tight upper bound for the size of the unknown vector in order to achieve good performance. Figures 15 and 16 show the results for the RS algorithm. Here, the performance improves gradually with an increase in block size. However, the speed of convergence is slow for a large block size (see Figure 15) even though a larger block size gives better performance at steady-state (see Figure 16). Again it can be inferred that it is best to keep the block size reasonably small in order to achieve a good trade off between performance and speed of convergence, especially when taking into account the fact that a larger block size would mean sensing more data for the same number of blocks.

### 6.5 Effect of network size

*N*= {10−50} while the forgetting factor is kept fixed at

*λ*= 0.9 for the RS algorithm and made variable for the RC algorithm. The block size is taken as

*K*= 8. This performance comparison is also carried out for both algorithms separately. The number of neighbors for each node is increased gradually as the size of the network is increased. Figures 17 and 18 show results for the RC algorithm. The performance is poor for

*N*= 10 but improves as

*N*increases. The initial speed of convergence is similar for various network sizes as can be seen in Figure 17 but, near steady-state, the networks with large sizes show a slight improvement in performance, as shown in Figure 18. Figures 19 and 20 show the results for the RS algorithm. Here the trend is slightly different. It can be seen that the initial speed of convergence improves with an increase in

*N*(see Figure 19) but the improvement in performance is slightly smaller near steady-state (see Figure 20). Also, the difference in performance is smaller for larger networks, which is as expected.

### 6.6 Effect of node malfunction

## 7 Conclusion

This work develops blind block recursive least squares algorithms based on Cholesky factorization and singular value decomposition (SVD). The algorithms are then used to estimate an unknown vector of interest in a wireless sensor network using cooperation between neighboring sensor nodes. Incorporating the algorithms in the sensor networks creates new diffusion-based algorithms, which are shown to perform much better than their non-diffusion-based counterparts. The new algorithms have been tested using both a variable as well as a fixed forgetting factor. The two developed algorithms are named diffusion blind block recursive Cholesky (DRC) and diffusion blind block recursive SVD (DRS) algorithms. Extensive simulation work comparing the two algorithms under different scenarios revealed that the DRS algorithm performs much better than the DRC algorithm but at the cost of a higher computational complexity. Also, of the two algorithms, the DRC algorithm performs better when the forgetting factor is variable whereas the DRS algorithm gives better results with a fixed forgetting factor. In the case of DRS, the value of the forgetting factor does not effect the overall performance a great deal except for a slight variation in convergence speed and steady-state performance. It was also seen that the size of the data block has an effect on the performance of the two algorithms. The speed of convergence slows down with an increasing block size which means an increasing amount of data to be processed. A block size increase, however, does not necessarily improve performance. It was found that, in general, a small block size gives a better performance. Therefore, it is essential to estimate a very low upper bound to the size of the unknown vector so that the data block size to be used is not unnecessarily large. Next, it was noticed that an increase in the network size improves performance but the improvement gradually decreases with an increasing network size. Moreover, it was shown that switching off some nodes with the largest neighborhoods can slightly degrade the performance of the algorithm. Finally at low SNRs, the Cholesky-based algorithm suffers from a severe degradation, whereas the SVD-based one only experiences a slight degradation.

## Declarations

### Acknowledgments

The authors acknowledge the support provided by the Deanship of Scientific Research (DSR) at KFUPM under Research Grants RG1216, RG1112, SB101024, and FT100012.

## Authors’ Affiliations

## References

- Sayed AH, Lopes CG: Distributed recursive least-squares strategies over adaptive networks. In
*Proceedings of the 40th Asilomar Conference on Signals, Systems, Computers*. Monterey, CA; 2006:233-237.Google Scholar - Lopes CG, Sayed AH: Incremental adaptive strategies over distributed networks.
*IEEE Trans. Signal Process*2007, 55: 4064-4077.MathSciNetView ArticleGoogle Scholar - Lopes CG, Sayed AH: Diffusion least-mean squares over adaptive networks: formulation and performance analysis.
*IEEE Trans. Signal Process*2008, 56(7):3122-3136.MathSciNetView ArticleGoogle Scholar - Schizas ID, Mateos G, Giannakis GB: Distributed LMS for consensus-based in-network adaptive processing.
*IEEE Trans. Signal Process*2009, 57(6):2365-2382.MathSciNetView ArticleGoogle Scholar - Bin Saeed MO, Zerguine A, Zummo SA: A variable step-size strategy for distributed estimation over distributed networks.
*Eur. J. Adv. Signal Process*2013, 2013: 135. 10.1186/1687-6180-2013-135View ArticleMATHGoogle Scholar - Sato Y: A method of self-recovering equalization for multilevel amplitude-modulation.
*IEEE Trans. Commun*1975, COM-23(6):679-682.View ArticleGoogle Scholar - Proakis J:
*Digital Communications*. McGraw-Hill, New York; 2000.MATHGoogle Scholar - Tong L, Perreau S: Multichannel blind identification: from subspace to maximum likelihood methods.
*Proc. IEEE*1998, 86(10):1951-1968. 10.1109/5.720247View ArticleGoogle Scholar - Xu G, Liu H, Tong L, Kailath T: A least-squares approach to blind channel identification.
*IEEE Trans. Signal Process*1995, 43(12):2982-2993. 10.1109/78.476442View ArticleGoogle Scholar - Abed-Meraim K, Qiu W, Hua Y: Blind system identification.
*IEEE Trans. Signal Process*1997, 45(3):770-773. 10.1109/78.558501View ArticleGoogle Scholar - Scaglione A, Giannakis GB, Barbarossa S: Redundant filterbank precoders and equalizers part II: blind channel estimation, synchronization, and direct equalization.
*IEEE Tran. Signal Proc*1999, 47(7):2007-2022. 10.1109/78.771048View ArticleGoogle Scholar - Manton JH, Neumann WD: Totally blind channel identification by exploiting guard intervals.
*Syst. Control Lett*2003, 48(2):113-119. 10.1016/S0167-6911(02)00278-5MathSciNetView ArticleMATHGoogle Scholar - Pham DH, Manton JH: A subspace algorithm for guard interval based channel identification and source recovery requiring just two received blocks. In
*Proceedings of the IEEE ICASSP ’03*. Hong Kong; 2003:317-320.Google Scholar - Su B, Vaidyanathan PP: A generalized algorithm for blind channel identification with linear redundant precoders.
*Eur. J. Adv. Signal Proc*2007, 2007: 1-13. Article ID 25672MathSciNetGoogle Scholar - Choi J, Lim C-C: A cholesky factorization based approach for blind FIR channel identification.
*IEEE Tran. Signal Proc*2008, 56(4):1730-1735.MathSciNetView ArticleGoogle Scholar - Cattivelli F, Sayed AH: Diffusion LMS strategies for distributed estimation.
*IEEE Trans. Signal Process*2010, 58(3):1035-1048.MathSciNetView ArticleGoogle Scholar

## Copyright

This article is published under license to BioMed Central Ltd. This is an Open Access article distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/4.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly credited.