A Low-Complexity Volterra Filtered-Error LMS Algorithm with a Kronecker Product Decomposition

Abstract

Nonlinear active control is very important in many practical applications. Many well-known nonlinear active noise control algorithms may suffer from high computational complexity and low convergence speed, especially in the nonlinear secondary path case. Thus, it is still an actively researched topic for reducing complexity and improving the convergence rate. This paper presents a low-complexity Volterra filtered-error least mean square algorithm when taking a decomposable Volterra model into account for active control of nonlinear noise processes, which is referred as DVMFELMS. The computational complexity analysis shows that the proposed DVMFELMS algorithm can significantly reduce the nonlinear active noise control system’s complexity. The simulation results further show that the proposed algorithm can achieve promising performance compared with the Volterra-based FELMS algorithm and other state-of-the-art nonlinear filters, while the decomposable error of the Volterra kernel may be introduced inevitably. Moreover, the proposed DVMFELMS algorithm shows a better convergence rate in the broadband primary noise case due to fewer parameters used in each sub-filter.

1. Introduction

Active noise control has developed rapidly in the last few decades [1,2], and it has been successfully applied in many fields, such as heating, ventilating and air-conditioning systems [3], motor systems [4], and active headrests [5,6]. An active noise control system can generate a sound wave with the same amplitude but inverse phase at the canceling point by utilizing the secondary loudspeaker. Compared with passive methods, active noise control has shown its potential in canceling low-frequency environmental noises. A huge amount of research has been conducted in this field that focuses on the performance limitation of the active noise control system [7,8], algorithms [9], and stability [10].

The most commonly used algorithm for a single-channel feedforward active noise control system is the filtered-reference least mean square (FXLMS) algorithm modeled by the finite impulse response (FIR) filter due to its stability and low computational complexity. Although the FXLMS algorithm has already been successfully applied in active noise control systems, its performance may degrade in controlling nonlinear noise processes [11]. It is well-known that nonlinear phenomena may occur in many circumstances. First, when the primary noise has a high sound pressure level, the primary path may suffer nonlinear processes. Second, when the secondary actuator works at a high sound pressure level or the size of the secondary loudspeaker is small but works at low frequencies, nonlinear distortion may occur at the secondary actuator [12]. Third, the primary noise may come from a dynamic system, such as a chaotic noise process. The transfer function of the secondary path may have a non-minimum phase, so that the causality constraint will be violated [11]. In all of these situations, the traditional linear structure cannot model the nonlinear part of the system accurately enough. To overcome these challenges, many researchers have proposed numerous ways when taking the nonlinearity of the system into account, which can be roughly divided into two categories [13,14]. The former one uses artificial neural networks to model the nonlinearity of the system [15,16]. However, most artificial neural network-based algorithms are too computationally consuming for real applications of active noise control systems, which is out of the scope of this paper. The latter one employs the modeling capability of adaptive nonlinear filters including adaptive Volterra filters [11,17], the functional link network (FLNN) [18] and its generalized form (GFLNN) [19], the exponential functional link network (EFLNN) [20], the even mirror Fourier nonlinear (EMFN) filter [21], the Legendre neural network (LeNN) [22], Chebyshev filters (CF) [23,24], and so on. Furthermore, due to the different properties of different algorithms, convex combinations of the above-mentioned nonlinear filters have also been studied to achieve better performance [25,26].

For active noise control systems, the influence of the secondary path must be considered for most algorithms. The NANC algorithm with a linear secondary path (LSP) and with a nonlinear secondary path (NSP) was unified in [27] by introducing a virtual secondary path into NANC with the NSP case. For most nonlinear filters, NANC with NSP case is more computationally consuming compared to NANC with the LSP case. The NANC problem with a nonlinear secondary path (NSP), however, is more important in real applications [12]. When the memory length becomes large, the algorithms mentioned above often require high computational complexity that cannot be neglected. There are two ways to reduce the computational complexity of the NANC algorithm. One way is to use the recursive structure, which can be seen as an expansion of the infinite impulse response (IIR) filter. This kind of NANC algorithm includes the bilinear filter algorithm [28,29], recursive second-order Volterra filter [30], recursive even mirror Fourier nonlinear filter [31,32], adaptive function expansion bilinear filter [33,34], and so on. However, it is worth noting that the stability of all recursive algorithms mentioned above should be carefully considered, and more efforts must be made to make the recursive algorithm stable [35]. The other way is to use the simplified structure firstly introduced in [36], which uses a diagonal channel structure of nonlinear filters and channel reduced strategy that only uses a few channels near the main one. Note that the choice of the number of the reduced channels may significantly influence the steady-state performance.

This paper focuses on a group of adaptive Volterra filter-based algorithms, which are widely used in practice and perform well in a low-order nonlinear case. The major challenge of these traditional Volterra filter-based algorithms is that the computational complexity increases rapidly with the increase of the length of the memory and the order of the Volterra kernel. Recently, the Kronecker product decomposition has been introduced to linear system identification [37] and acoustic echo cancellation [38]. When using the Kronecker product decomposition, the computational complexity can be reduced dramatically in theory. In addition, it is demonstrated that the decomposable Volterra model outperforms the simplified structure in [36]. Motivated by these latest works, this paper proposes an adaptive Volterra-filtered error least mean square algorithm (DVMFELMS) that takes a decomposable Volterra model and filtered-error structure into account for the nonlinear active control problem. By comparing the computational complexity and the convergence performance of the proposed algorithm with the linear FELMS algorithm, VFELMS algorithm [11], FEGFLNN algorithm [19], and FEEMFNL algorithm [39], this paper shows that the proposed algorithm not only reduces the computational complexity, but also improves the convergence behavior slightly in the broadband noise cases.

The remainder of this paper is organized as follows. Section 2 formulates the problem of nonlinear active noise control. Section 3 derives the proposed DVMFELMS algorithm, and Section 4 compares its computational complexity with some state-of-the-art nonlinear filter algorithms. Simulation and conclusions are presented in Section 5 and Section 6, respectively.

2. Problem Formulation

2.1. Linear Feedforward ANC System

Before describing the nonlinear active noise control problem, the standard linear feedforward active noise control structure is first depicted in Figure 1 [1]. $u\left(n\right)$ is the reference signal at the time index n recorded by the reference microphone, and $y\left(n\right)$ is the output of the secondary actuator, which can be expressed as

$$y\left(n\right)=w\left(n\right)\ast u\left(n\right),$$

(1)

where $w\left(n\right)$ is the coefficient of the active noise control filter, and * denotes the linear convolution. $e\left(n\right)$ is the residual error sensed by the error microphone, which can be expressed as

$$e\left(n\right)=d\left(n\right)+y\left(n\right)\ast \mathit{s}\left(n\right),$$

(2)

where $S\left(z\right)$ and $\widehat{S}\left(z\right)$ are the secondary path transfer function and its estimation, respectively. $P\left(z\right)$ is the primary path transfer function, and $d\left(n\right)$ is the primary noise signal at the error microphone.

In a standard linear feedforward active noise control structure, our goal is to find a suitable output signal $y\left(n\right)$ to minimize the mean square of the error signal $e\left(n\right)$. All transfer functions and control filters are assumed to be linear, which may be violated in many circumstances, as mentioned above.

2.2. Nonlinear Feedforward ANC System

This paper expresses the nonlinear process using the well-known Volterra structure [11], where the Volterra series representation of $y\left(n\right)$ can be given by

$$y\left(n\right)=\sum _{p=0}^{\infty }{y}_p\left(n\right),$$

(3)

where

$$y_p\left(n\right)=\sum _{0\le l_1,\cdots ,l_p\le L}{h}_p(l_1,\cdots ,l_p)\times u(n-l_1)\times \cdots \times u(n-l_p),$$

(4)

$h_p(l_1,\cdots ,l_p)$ is the p-th-order Volterra kernel, and $L+1$ is the length of the memory. Equation (4) can be further expressed in the vector form as below:

$$y_p\left(n\right)={\mathit{U}}_p^T\left(n\right){\mathit{H}}_p\left(n\right),$$

(5)

where T denotes transportation operation, and ${\mathit{U}}_p\left(n\right)$ is the p-th-order reference vector with the length ${(L+1)}^p$, which is: -4.6cm0cm

$$\begin{array}{c}\hfill {\mathit{U}}_p\left(n\right)={[u\left(n\right)\times \cdots \times u\left(n\right),\cdots ,u(n-l_1)\times \cdots \times u(n-l_p),\cdots ,u(n-L)\times \cdots \times u(n-L)]}^T,\end{array}$$

(6)

and similarly, ${\mathit{H}}_p\left(n\right)$ is the p-th-order Volterra kernel vector with length ${(L+1)}^p$ given by

$$\begin{array}{c}\hfill {\mathit{H}}_p\left(n\right)={[h_p(0,\cdots ,0),\cdots ,h_p(l_1,\cdots ,l_p),\cdots ,h_p(L,\cdots ,L)]}^T.\end{array}$$

(7)

This Volterra expression can be regarded as a Taylor expansion of the generally nonlinear function. Generally, only the first P order Volterra kernels are used to model the system’s nonlinearity, although the truncated error may be introduced inevitably.

3. Proposed Algorithm

After considering a decomposable Volterra model, a low-complexity adaptive Volterra algorithm based on a filtered-error structure is proposed in this section for both nonlinear active noise control (NANC) with a linear secondary path (LSP) and that with a nonlinear secondary path (NSP). By using the Kronecker product decomposition, the system’s computational complexity can be reduced dramatically, which is promising for active noise control systems.

3.1. DVMFXLMS

To derive the DVMFELMS algorithm, the adaptive Volterra algorithm based on a filtered-reference structure (DVMFXLMS) is first derived in this part. To model the system’s nonlinearity, a P-order Volterra model with the length of the memory $L+1$ is utilized. By using the Kronecker product decomposition and the characteristic of the Kronecker product [38], Equation (5) can be rewritten as

$$\begin{array}{cc}\hfill y_p\left(n\right)& ={(\mathit{u}\left(n\right)\otimes \cdots \otimes \mathit{u}\left(n\right))}^T({\mathit{w}}_{p,1}\left(n\right)\otimes \cdots \otimes {\mathit{w}}_{p,p}\left(n\right)),\hfill \\ \hfill & =\left({\mathit{u}}^T\left(n\right){\mathit{w}}_{p,1}\left(n\right)\right)\otimes \cdots \otimes \left({\mathit{u}}^T\left(n\right){\mathit{w}}_{p,p}\left(n\right)\right),\hfill \\ \hfill & =\left({\mathit{u}}^T\left(n\right){\mathit{w}}_{p,1}\left(n\right)\right)\times \cdots \times \left({\mathit{u}}^T\left(n\right){\mathit{w}}_{p,p}\left(n\right)\right),\hfill \end{array}$$

(8)

where ⊗ denotes the Kronecker product, and $\mathit{u}\left(n\right)$ is the primary noise vector given by

$$\mathit{u}\left(n\right)={[u\left(n\right),u(n-1),\cdots u(n-L)]}^T,$$

(9)

where ${\mathit{w}}_{p,1}\left(n\right)\otimes \cdots \otimes {\mathit{w}}_{p,p}\left(n\right)$ is the nearest Kronecker product decomposition of ${\mathit{H}}_p\left(n\right)$, which can be expressed as

$$\underset{{\mathit{w}}_{p,q}(0\le p\le P,0\le q\le p)}{argmin}\left|\right|{\mathit{H}}_p\left(n\right)-{\mathit{w}}_{p,1}\left(n\right)\otimes \cdots \otimes {\mathit{w}}_{p,p}\left(n\right){\left|\right|}^2,$$

(10)

where ${\left|\right|.\left|\right|}^2$ is the $l_2$-norm of a vector, and ${\mathit{w}}_{p,q}\left(n\right)$ is the q-th filter of the p-th-order of the decomposed Volterra structure with memory length $L+1$, which is defined as

$$\begin{array}{c}\hfill {\mathit{w}}_{p,q}\left(n\right)={[w_{p,q}(n,0),w_{p,q}(n,1),\cdots w_{p,q}(n,L)]}^T,with0\le p\le P,0\le q\le p.\end{array}$$

(11)

Minimizing the mean square error can be given by

$$\begin{array}{cc}\hfill J& =E\left\{e{\left(n\right)}^2\right\},\hfill \\ \hfill & =E\left\{{\left(d\left(n\right)+\widehat{d}\left(n\right)\right)}^2\right\}.\hfill \end{array}$$

(12)

According to the steepest descent algorithm, the proposed FXLMS can update the sub-filter ${\mathit{w}}_{p,q}\left(n\right)$ as follows:

$${\mathit{w}}_{p,q}(n+1)={\mathit{w}}_{p,q}\left(n\right)-{\mu }_p\frac{\partial J}{\partial {\mathit{w}}_{p,q}}{|}_{n^{\prime }}$$

(13)

where $\frac{\partial J}{\partial {\mathit{w}}_{p,q}}{|}_n$ is the single sample estimation of the gradient of J, and ${\mu }_p$ is the step size. Defining $y_{p,q}\left(n\right)={\mathit{u}}^T\left(n\right){\mathit{w}}_{p,q}\left(n\right)$, $y\left(n\right)$ can be rewritten as

$$y\left(n\right)=\sum _{p=1}^P\left(\prod _{q=1}^p{y}_{p,q}\left(n\right)\right).$$

(14)

We further assume that ${\mathit{w}}_{p,q}\left(n\right)$ only changes slowly, and we can derive the gradient in Equation (13) by substituting Equations (12) and (14) into Equation (15):

$$\frac{\partial J}{\partial {\mathit{w}}_{p,q}}{|}_n=\left(\left(\prod _{s=1}^{q-1}{y}_{p,s}\left(n\right)\prod _{s=q+1}^p{y}_{p,s}\left(n\right)\mathit{u}\left(n\right)\right)\ast \frac{\partial \widehat{d}\left(n\right)}{\partial \mathit{y}\left(n\right)}\right)e\left(n\right),$$

(15)

defining the virtual secondary path filter $\mathit{s}\left(n\right)$ with memory length $M+1$:

$$\mathit{s}\left(n\right)={\left[\frac{\partial \widehat{d}\left(n\right)}{\partial y\left(n\right)},\frac{\partial \widehat{d}\left(n\right)}{\partial y(n-1)},\cdots \frac{\partial \widehat{d}\left(n\right)}{\partial y(n-M)}\right]}^T,$$

(16)

and, for notation convenience, defining an auxiliary sub-vector:

$${\overline{\mathit{u}}}_{p,q}\left(n\right)={\overline{y}}_{p,q}\left(n\right)\mathit{u}\left(n\right),$$

(17)

where ${\overline{y}}_{p,q}\left(n\right)=\left({\prod }_{s=1}^{q-1}{y}_{p,s}\left(n\right){\prod }_{s=q+1}^p{y}_{p,s}\left(n\right)\right)$. Substituting Equations (15)–(17) into Equation (13), we can derive the updating equation of ${\mathit{w}}_{p,q}\left(n\right)$ for all p and q as

$${\mathit{w}}_{p,q}(n+1)={\mathit{w}}_{p,q}\left(n\right)-{\mu }_p\left({\overline{\mathit{u}}}_{p,q}\left(n\right)\ast \mathit{s}\left(n\right)\right)e\left(n\right).$$

(18)

It is worth noting that for NANC with the LSP case, the virtual secondary path filter $\mathit{s}\left(n\right)$ can be modeled offline using a linear FIR filter. For NANC with the NSP case, the virtual secondary path filter will change with the iteration, even though the nonlinear secondary path is time-invariant. Thus, the nonlinear secondary path must be modeled firstly based on one of the nonlinear filters mentioned above, such as the Volterra filter. Then, the derivation in Equation (16) is calculated using the modeled nonlinear filter. A sparse modeling method of the nonlinear secondary path using a second-order Volterra filter can be used here to reduce the computational complexity [39].

To improve the stability of the proposed algorithm, a normalized method is considered, and a regularization parameter $\lambda$ is also introduced, which is similar to [38]. The updating equation of each sub-filter is finally given by

$${\mathit{w}}_{p,q}(n+1)={\mathit{w}}_{p,q}\left(n\right)-{\tilde{\mu }}_p\left({\overline{\mathit{u}}}_{p,q}\left(n\right)\ast \mathit{s}\left(n\right)\right)e\left(n\right),$$

(19)

where

$${\tilde{\mu }}_p=\frac{{\mu }_p}{\left|\right|{\overline{y}}_{p,q}\left(n\right){\left|\right|}^2+{\lambda }_p}.$$

(20)

3.2. DVMFELMS

It should be noted that the auxiliary vector ${\overline{\mathit{u}}}_{p,q}\left(n\right)$ defined in Equation (17) did not hold the time-shifting property due to the presence of defined in Equation (17) did not hold the time-shifting property due to the presence of ${\overline{y}}_{p,q}\left(n\right)$; thus, each element of ${\overline{\mathit{u}}}_{p,q}\left(n\right)$ must be filtered by the virtual secondary path filter even in the LSP case, which is a computationally consuming process. It was found that the filtered-error structure-based ANC system can offer comparable performance with less computational and structural complexity compared to a filtered-reference structure-based ANC [40]. Zhou and Debrunner introduced the filtered-error structure to nonlinear active noise to reduce the computational complexity in the NSP case [27]. The filtered-error structure’s main advantage is that only the error signal needs to be filtered by the virtual secondary path filter, which benefits the proposed nonlinear active noise control algorithm based on the decomposable Volterra structure.

The diagram of the proposed DVMFELMS algorithm is depicted in Figure 2. To derive the DVMFELMS algorithm, the final updating equation of the DVMFXLMS algorithm is first recalled in the following:

$${\mathit{w}}_{p,q}(n+1)={\mathit{w}}_{p,q}\left(n\right)-{\tilde{\mu }}_p\left(n\right)\left({\overline{\mathit{u}}}_{p,q}\left(n\right)\ast \mathit{s}\left(n\right)\right)e\left(n\right).$$

(21)

Rewriting the update part of Equation (21) as

$$\mathsf{\Delta }{\mathit{w}}_{p,q}\left(n\right)=-\left(\sum _{m=0}^M{\overline{\mathit{u}}}_{p,q}(n-m)\mathit{s}(n,m)\right)e\left(n\right),$$

(22)

and let $k=n-m+M$; then, $n=k+m-M$. Equation (22) can be written as

$$\mathsf{\Delta }{\mathit{w}}_{p,q}\left(n\right)=-\left(\sum _{m=0}^{M}e(k+m-M)\mathit{s}(k+m-M,m)\right){\overline{\mathit{u}}}_{p,q}(k-M).$$

(23)

By substituting the time variable, only the error signal is filtered by the adjoint virtual secondary path filter $\overline{\mathit{s}}\left(n\right)$, which is defined in the following instead of the whole new auxiliary sub-vector ${\overline{\mathit{u}}}_{p,q}\left(n\right)$.

$$\overline{\mathit{s}}\left(n\right)={\left[s(n,M),s(n-1,M-1),\cdots s(n-M,0)\right]}^T,$$

(24)

It should be noted that in the LSP case, the adjoint virtual secondary path filter is just the flip of the linear FIR filter in Equation (16), while for the NSP case, due to the time-variant property of the virtual secondary path filter, the last M values of the virtual secondary path filter must be stored to reconstruct the adjoint virtual secondary path filter. The final update equation of the proposed DVMFELMS algorithm is given by

$${\mathit{w}}_{p,q}(n+1)={\mathit{w}}_{p,q}\left(n\right)-{\tilde{\mu }}_p{\overline{\mathit{u}}}_{p,q}(n-M)e_f\left(n\right),$$

(25)

where $e_f\left(n\right)$ is the filtered-error signal calculated by filtering the error signal by the adjoint virtual secondary path filter defined in Equation (24). From Equation (25), one can see that the auxiliary vector ${\overline{\mathit{u}}}_{p,q}\left(n\right)$ is just delayed by the M time scale without being filtered by the virtual secondary path filter, while only the error signal needs to be filtered by the adjoint virtual secondary path filter. Thus, the computational complexity of the proposed algorithm can be further reduced, especially when the memory of the secondary path becomes large. The detailed implementation of the proposed DVMFELMS algorithm is summarized in Algorithm 1.

Algorithm 1 Pseudo code of the proposed DVMFELMS algorithm.

Input:L, M, P, $\mu$,reference signals $u\left(n\right)$, desired signals $d\left(n\right)$, secondary path $\mathit{s}\left(n\right)$, adjoint virtual secondary path $\overline{\mathit{s}}\left(n\right)$

Initialization:

1: for $p=1$; $p<P+1$; $p++$ do 2:     for $q=1$; $q<p$; $q++$ do 3:         ${\mathit{w}}_{p,q}\left(0\right)={[2^{1-q},0,\cdots 0]}^T$ 4:     end for 5:     ${\mathit{w}}_{p,p}\left(0\right)={[0,0,\cdots 0]}^T$ 6: end for

Iteration:

7: for $n=0$ to $END$ do 8:     for $p=1$; $p<P+1$; $p++$ do 9:         $y_p\left(n\right)=1$ 10:         for $q=1$; $q<p+1$; $q++$ do 11:            $y_p\left(n\right)=y_p\left(n\right)\left({\mathit{u}}^T\left(n\right){\mathit{w}}_{p,q}\left(n\right)\right)$ 12:         end for 13:     end for 14:     calculate the output signal $y\left(n\right)={\sum }_{p=0}^P{y}_p\left(n\right)$ 15:     calculate the error signal $e\left(n\right)=d\left(n\right)+y\left(n\right)\ast \mathit{s}\left(n\right)$ 16:     calculate the filtered-error signal $e_f\left(n\right)=e\left(n\right)\ast \overline{\mathit{s}}\left(n\right)$ 17:     for $p=1$; $p<P+1$; $p++$ do 18:         for $q=1$; $q<p+1$; $q++$ do 19:            calculate the auxiliary sub-vector ${\overline{\mathit{u}}}_{p,q}\left(n\right)={\overline{y}}_{p,q}\left(n\right)\mathit{u}\left(n\right)$ and gain ${\overline{\mathit{u}}}_{p,q}(n-M)$ 20:            update ${\mathit{w}}_{p,q}(n+1)={\mathit{w}}_{p,q}\left(n\right)-{\tilde{\mu }}_p{\overline{\mathit{u}}}_{p,q}(n-M)e_f\left(n\right)$ 21:         end for 22:     end for 23: end for

Output: error signals $e\left(n\right)$, output signals $y\left(n\right)$, and filter coefficients ${\mathit{w}}_{p,q}\left(n\right)$

4. Computational Complexity

The proposed algorithm’s computational complexity is analyzed and compared with state-of-the-art nonlinear filters in NANC, including the Volterra filter [11], GFLNN [19], and second-order EMFNL (2OEMFNL) [39]. The computational complexity based on the filtered-reference and the filtered-error structure is considered. The computational load per iteration can be calculated according to L, M, and P. Note that only the multiplications required for all algorithms are considered in this section.

The number of multiplications of the proposed DVMFXLMS algorithm is first calculated in the following. The number of multiplications for generating the pth-order output $y_p\left(n\right)$ is $Lp+1$. The number of multiplications for the pth-order filtered-reference signal vector is $Lp(M+1)+3(p-2)$, and for the updating weights, the number of multiplications is $Lp$. In all, the total number of multiplications of the proposed DVMFXLMS algorithm is

$$\begin{array}{cc}\hfill T_{\mathrm{DVMFXLMS}}& =\sum _{p=1}^P(Lp(M+3)+3p-5),\hfill \\ \hfill & =\frac{(P+1)P(LM+3L+3)}{2}-5P,\hfill \end{array}$$

(26)

The computational complexity required for VFXLMS, FXGFLNN, 2OFXEMFNL, and the proposed DVMFXLMS algorithm for NANC with NSP is summarized in

Table 1. Computational complexity of different algorithms for NANC with the NSP using filtered-reference structure.

Algorithm	VFXLMS	FXGFLNN	2OFXEMFNL	DVMFXLMS
Inputs signal	$\frac{(P+L-1)!}{L!(P-1)!}-1$	$2LP$	$L-1$	1
Output signal	$\frac{(P+L)!}{L!P!}-1$	$P{L}^2-(P-3)L$	$\frac{L^2+5L}{2}$	$\frac{LP(P+1)}{2}+$P
Filtered signal	$\frac{M(P+L)!}{L!P!}$	$(P{L}^2-(P-3)L)M$	$\frac{M(L^2+5L)}{2}$	$\frac{\left(L\right(M+1)+3)P(P+1)}{2}-$$5P$
Weight update	$2\left(\frac{(P+L)!}{L!P!}-1\right)$	$2P{L}^2-2(P-3)L$	$L^2+5L$	$\frac{LP(P+1)}{2}$
Total	$\frac{(P+L-1)!(MP+ML+4P+3L)}{P!L!}-4$	$(M+3)(P{L}^2-2(P-3)L)+2LP$	$\frac{(M+3)(L^2+5L)}{2}+$$L-1$	$\frac{\left(L\right(M+3)+3)P(P+1)}{2}-$$4P$

. It can be seen that the VFXLMS algorithm has the highest computational complexity. The 2OFXEMFNL algorithm and the FXGFLNN algorithm can achieve comparable performance with less computational complexity in higher-order nonlinearity. The proposed DVMFXLMS algorithm has the lowest computational complexity due to the Kronecker product decomposition and a similar property against the VFXLMS algorithm; however, due to the decomposition error of Equation (10), its performance may have some degradations in some real applications, which will be analyzed in next section. From Table 1, it should be noted that the number of multiplications of the DVMFXLMS algorithm for generating the filtered signal are computationally consuming. The computational complexity required for the DVMFELMS algorithm is then calculated. From Equation (25), the difference between the filtered-reference and filtered-error structure is the generation of the filtered signal. In the DVMFELMS algorithm, only the error vector needed to be filtered by the adjoint virtual secondary path filter; thus, only M multiplications are needed for all the sub-filter updates. While the generation of all p-th order auxiliary vector ${\overline{\mathit{u}}}_{p,q}\left(n\right)$ needs $Lp+3(p-2)$ multiplications, the total complexity of the DVMFELMS algorithm is calculated as

$$\begin{array}{cc}\hfill T_{\mathrm{DVMFELMS}}& =\sum _{p=1}^P(3Lp+3p-1)+M,\hfill \\ \hfill & =\frac{(P+1)P(3L+3)}{2}-P+M,\hfill \end{array}$$

(27)

The computational complexity required for the VFELMS algorithm, the FEGFLNN algorithm, the 2OFEEMFNL algorithm, and the proposed DVMFELMS algorithm for NANC with an NSP case is summarized in

Table 2. Computational complexity of different algorithms for NANC with the NSP using filtered-error structure.

Algorithm	VFELMS	FEGFLNN	2OFEEMFNL	DVMFELMS
Inputs signal	$\frac{(P+L-1)!}{L!(P-1)!}-1$	$2LP$	$L-1$	1
Output signal	$\frac{(P+L)!}{L!P!}-1$	$P{L}^2-(P-3)L$	$\frac{L^2+5L}{2}$	$\frac{LP(P+1)}{2}+$P
Filtered signal	M	M	M	M
Weight update	$2\left(\frac{(P+L)!}{L!P!}-1\right)$	$2P{L}^2-2(P-3)L$	$L^2+5L$	$\frac{LP(P+1)}{2}$
Total	$\frac{(P+L-1)!(4P+3L)}{P!L!}-4$	$3(P{L}^2-2(P-3)L)+2LP+M$	$\frac{3(L^2+5L)}{2}+$$M+L-1$	$\frac{(P+1)P(3L+3)}{2}-P+M$

. In order to make the computational complexity required for all algorithms visible, the number of multiplications required for all algorithms versus memory length is shown in Figure 3, while the length of the secondary path M is 10 for all the cases. It is worth noting that only the NANC with the NSP case is considered in this section because the NANC with the LSP can be seen as a special case for NANC with NSP. In addition, for structures that have a time-shifting property, such as the Volterra filter, GFLNN, and EMFNL, the computational complexity required for all algorithms in NANC with the LSP case based on the filtered-reference structure is almost the same as in NANC with the NSP case based on the filtered-error structure, while for the proposed algorithm, the computational complexity required for all algorithms in NANC with the LSP case based on the filtered-reference structure is the same as in NANC with the NSP case regardless of the computational complexity of the generation of the virtual secondary path filter. Figure 3 shows that the filtered-error structure can reduce the computational complexity in the NANC with the NSP case for all algorithms. With the growth of memory length, the computational complexity of the VFELMS algorithm can be intolerable for ANC systems. The computational complexity of the GFLNN and EMFNL structure is smaller than the VFELMS algorithm, while it is still large for a real-time system. However, by utilizing a decomposable Volterra structure and filtered-error structure, the proposed DVMFELMS algorithm can significantly reduce the computational complexity of the algorithm, which is promising in NANC systems, especially for the NSP case.

5. Performance Evaluation

This section evaluates the proposed DVMFELMS algorithm’s performance and compares it with the FELMS algorithm, the VFELMS algorithm, the FEGFLNN algorithm, and the FEEMFNL algorithm. We evaluate the algorithms in three different nonlinear situations; the primary path has a nonlinear process in the first case, the primary and secondary paths have nonlinearity in the second case, and there is a real measured path with an intensely saturated signal in the last case. The normalized mean square error (NMSE) [11] is used to evaluate the performance of the algorithm, which is defined as

$$NMSE=10{log}_{10}\left(\frac{E\left\{e^2\left(n\right)\right\}}{{\sigma }_d^2}\right),$$

(28)

where ${\sigma }_d^2$ is the mean square energy of the primary noise. All results presented in this section are based on an ensemble average of 100 independent runs for each algorithm. The primary path $P\left(z\right)$ is set to be $-P\left(z\right)$ in the middle of the iteration to study all algorithms’ stability and tracking capability. Furthermore, the step-sizes are all selected to achieve the maximum convergence rate with the minimum achievable NMSE.

5.1. Simulation with Nonlinear Primary Path

In the first experiment, the situation where the primary path has a nonlinear process is studied. The primary noise recorded by the error microphone is generated by passing the reference signal through a third-order Volterra model with cross terms, which is given by

$$\begin{array}{cc}\hfill d\left(n\right)& =u(n-5)+0.8u(n-6)+0.3u(n-7)+0.4u(n-8)\hfill \\ \hfill & +0.2u(n-5)u(n-6)-0.3u(n-5)u(n-7)+0.4u(n-5)u(n-8)\hfill \\ \hfill & +0.04u(n-5)u(n-6)u(n-7)-0.02u(n-5)u(n-6)u(n-8),\hfill \end{array}$$

(29)

where the transfer function of the secondary path is $S\left(z\right)=z^{-2}+0.3z^{-3}$. The reference noise signal $u\left(n\right)$ is considered to be two cases; a sinusoidal wave of 500 Hz with a sampling rate of 8000 Hz is utilized in the first case, and a band-limited white Gaussian noise in the second case. The sinusoidal reference signal is given by

$$u\left(n\right)=\sqrt{2}sin\left(\frac{2\pi \times 500\times n}{8000}\right)+v\left(n\right),$$

(30)

where $v\left(n\right)$ is a white Gaussian noise with zero mean and unit variance, and the signal-to-noise ratio (SNR) is set to be 30 dB. The memory length for all algorithms is chosen to be 10. The order of the Volterra kernel is chosen to be 3, and the order of the functional link neural network and even mirror Fourier nonlinear filter is chosen to be 2. The step size for the FELMS algorithm is chosen to be ${\mu }_1=2\times {10}^{-3}$, step sizes for the third-order Volterra filter are set to ${\mu }_1=2\times {10}^{-3},{\mu }_2=1\times {10}^{-3},{\mu }_3=6\times {10}^{-4}$, step sizes for the 2OFEGFLNN algorithm and 2OFEEMFNL algorithm are set to ${\mu }_1=2\times {10}^{-3},{\mu }_2=1\times {10}^{-3}$, and step sizes for the 3ODVMFELMS algorithm are set to ${\mu }_1=2\times {10}^{-3},{\mu }_2=2\times {10}^{-2},$${\mu }_3=1\times {10}^{-4},{\lambda }_2=0.6,{\lambda }_3=0.04$.

Figure 4 shows the NMSE achieved by all five algorithms versus the number of iterations in the sinusoidal noise case. It can be seen from Figure 4 that the reduction of primary noise achieved by the FELMS algorithm, the 3OVFELMS algorithm, the 2OFEGFLNN algorithm, the 2OFEEMFNL algorithm, and the 3ODVMFELMS algorithm is about 22.5 dB, 25.3 dB, 25.9 dB, 26.2 dB, and 26.3 dB, respectively. All nonlinear algorithms achieve better performance against the FELMS algorithm. The proposed DVMFELMS algorithm performs slightly better in the steady-state performance and the convergence rate in this case. It should be noted that the proposed DVMFELMS algorithm can even outperform the VFELMS algorithm in NMSE, which might be explained by the Volterra model used in the VFELMS algorithm being over-fitting for this simulation case.

For results of the broadband noise, the frequency range of the band-limited noise is chosen to be from 50 Hz to 1000 Hz, among which the ANC system usually works well. The signal is normalized to unity, and a white Gaussian noise with zero mean and unit variance with an SNR of 30 dB is also added. All the transfer functions and nonlinearities used are exactly the same as in the first case. The step size for the FELMS algorithm is chosen to be ${\mu }_1=6\times {10}^{-3}$, step sizes for the third-order Volterra filter are set to ${\mu }_1=6\times {10}^{-3},{\mu }_2=4\times {10}^{-3},{\mu }_3=6\times {10}^{-4}$, step sizes for the 2OFEGFLNN algorithm and 2OEMFNL algorithm are set to ${\mu }_1=6\times {10}^{-3},{\mu }_2=1\times {10}^{-3}$, and step sizes for the 3ODVMFELMS algorithm are set to ${\mu }_1=6\times {10}^{-3},{\mu }_2=4\times {10}^{-3},{\mu }_3=1\times {10}^{-3},$${\lambda }_2=0.02,{\lambda }_3=0.02$. Figure 5 shows that the reduction of primary noise achieved by the FELMS algorithm, the 3OVFELMS algorithm, the FEGFLNN algorithm, the 2OEMFNL algorithm, and the 3ODVMFELMS algorithm in the broadband noise case is about 19.8 dB, 23.8 dB, 23.2 dB, 23 dB, and 23.6 dB, respectively. It is worth noting that in the broadband case, the VFELMS algorithm outperforms the 2OFEGFLNN algorithm and the 2OEMFNL algorithm in NMSE, which coincides with the results in [19]. Nevertheless, the 2OEMFNL algorithm has a fast convergence rate due to its inherent property, as shown in [27]. The proposed DVMFELMS algorithm can achieve comparable steady-state performance against the VFELMS algorithm, while with a slightly faster convergence rate. This may be explained by the fewer parameters used in the DVMFELMS algorithm.

5.2. Simulation with Nonlinear Primary Path and Nonlinear Secondary Path

To further demonstrate the effectiveness of the proposed DVMFELMS algorithms in the NANC/NSP case, both primary and secondary paths are considered to have nonlinearity in this experiment. The primary noise recorded by the error microphone is generated by passing the reference signal through a second-order Volterra model given by

$$\begin{array}{cc}\hfill d\left(n\right)& =u(n-5)+0.8u(n-6)+0.3u(n-7)+0.4u(n-8)\hfill \\ \hfill & +0.2u(n-5)u(n-6)-0.3u(n-5)u(n-7)+0.4u(n-5)u(n-8),\hfill \end{array}$$

(31)

while the secondary path is considered to be an NLN model used in [27], which is expressed as

$$\begin{array}{cc}\hfill & l_1=1-0.6z^{-1}+0.05z^{-2},\hfill \\ \hfill & N\left(z_1\left(n\right)\right)=3.3tanh\left(0.3z_1\left(n\right)\right),\hfill \\ \hfill & l_2=1+0.2z^{-1}+0.05z^{-2}.\hfill \end{array}$$

(32)

Figure 6 depicts the NMSE obtained by all five active noise control algorithms versus the number of iterations by using the same sinusoidal signal as the reference signal in Equation (30). The memory length for all algorithms is chosen to be 10, and the order of the Volterra kernel is chosen to be 2. The step size for the FELMS algorithm is chosen to be ${\mu }_1=2\times {10}^{-1}$, step sizes for the second-order Volterra filter are set to ${\mu }_1=2\times {10}^{-1},{\mu }_2=2\times {10}^{-1}$, step sizes for the FEGFLNN algorithm are chosen to be ${\mu }_1=2\times {10}^{-1},{\mu }_2=4\times {10}^{-3}$, step sizes for the 2OEMFNL algorithm are set to ${\mu }_1=2\times {10}^{-1},{\mu }_2=1\times {10}^{-2}$, and step sizes for the 2ODVMFELMS algorithm are set to ${\mu }_1=2\times {10}^{-1},{\mu }_1=2\times {10}^{-2},{\lambda }_2=0.02$. Figure 6 shows that the reductions of primary noise achieved by the FELMS algorithm, the 2OVFELMS algorithm, the 2OFEGFLNN algorithm, the 2OFEEMFNL algorithm, and the proposed 2ODVMFELMS algorithm are about 20.8 dB, 29.7 dB, 29.3 dB, 29.1 dB, and 29.7 dB, respectively. It should be noted that the FEEMFNL algorithm shows bad convergence speed in the NSP case. The proposed DVMFELMS algorithm can still achieve comparable performance with the lowest computational complexity in the NSP case. However, the convergence rate of the proposed 2ODVMFELMS algorithm is worse in these cases because of the sinusoidal signal and NSP used.

For broadband results, the band-limited white Gaussian noise used here is exactly the same as in experiment 2. The SNR is also set to be 30 dB. All the transfer functions are exactly the same as in the first case. Figure 7 shows the NMSE achieved by all five algorithms versus the number of iterations. The step size for the FELMS algorithm is chosen to be ${\mu }_1=2\times {10}^{-1}$, step sizes for the second-order Volterra filter are set to ${\mu }_1=2\times {10}^{-1},{\mu }_2=2\times {10}^{-1}$, step sizes for the 2OFEGFLNN algorithm are chosen to be ${\mu }_1=2\times {10}^{-1},{\mu }_2=4\times {10}^{-3}$, step sizes for the 2OEMFNL algorithm are set to ${\mu }_1=2\times {10}^{-1},$${\mu }_2=1\times {10}^{-2}$, and step sizes for the 2ODVMFELMS algorithm are set to ${\mu }_1=2\times {10}^{-1},$${\mu }_1=2\times {10}^{-2},{\lambda }_2=0.02$. One can see from Figure 7 that the reductions of primary noise achieved by the FELMS algorithm, the 2OVFELMS algorithm, the 2OFEGFLNN algorithm, the 2OEMFNL algorithm, and the 2ODVMFELMS algorithm are about 17.3 dB, 24.1 dB, 23.7 dB, 23.5 dB, and 23.8 dB, respectively. It can be seen that the FEFLNN algorithm and the FEEMFNL algorithm show worse performance in steady-state NMSE and convergence speed than the Volterra filter-based algorithm in the broadband reference signal and NSP case. The proposed DVMFELMS algorithm has performance comparable with the VFELMS algorithm, with a dramatic reduction of computational complexity.

5.3. Simulation with Measured Primary Path and Secondary Path

In this experiment, a real measured primary and secondary path is used to justify the proposed DVMFELMS algorithm’s effectiveness in a real application. The amplitude and phase response of both primary and secondary paths is shown in Figure 8. The reference signal is chosen to be three sinusoidal waves at normalized frequencies of 0.01, 0.02, and 0.08, which is normalized to unity power [29]. A white Gaussian noise with zero mean and unit variance with a signal-to-noise ratio of 30 dB is also added. Furthermore, the reference signal is assumed to have strong saturation generated by clipping the reference at 50% of the maximum signal value. The memory length of the primary and secondary path is chosen to be 80. Figure 9 shows the NMSE achieved by all five algorithms versus the number of iterations. The step size for the FELMS algorithm is chosen to be ${\mu }_1=1\times {10}^{-4}$, step sizes for the second-order Volterra filter are set to ${\mu }_1=1\times {10}^{-4},{\mu }_2=1\times {10}^{-4}$, step sizes for the 2OFEGFLNN algorithm are chosen to be ${\mu }_1=1\times {10}^{-4},{\mu }_2=5\times {10}^{-6}$, step sizes for the 2OFEEMFNL algorithm are set to ${\mu }_1=1\times {10}^{-4},{\mu }_2=4\times {10}^{-5}$, and step sizes for the 2ODVMFELMS algorithm are set to ${\mu }_1=1\times {10}^{-4},{\mu }_1=1\times {10}^{-3},{\lambda }_2=0.02$. Figure 9 shows that the reduction of primary noise achieved by the FELMS algorithm, the 2OVFELMS algorithm, the FEGFLNN algorithm, the 2OEMFNL algorithm, and the 2ODVMFELMS algorithm in the real measured primary and secondary path cases is about 27.5 dB, 29.7 dB, 29.6 dB, 29.9 dB, and 29.6 dB, respectively. From Figure 9, it can be seen that the 2OEMFNL algorithm outperforms all algorithms in NMSE, while having the lowest convergence speed. The proposed DVMFELMS algorithm can achieve almost the same NMSE compared with the VFELMS algorithm in this case. The number of multiplications in this experiment for all four nonlinear algorithms are 278960, 39210, 10289, and 958, respectively, which shows the potential in the real application of the proposed DVMFELMS algorithm.

6. Conclusions

This paper proposes a very low-complexity adaptive Volterra filter-error least mean square algorithm for the active control of nonlinear noise processes after considering a decomposable Volterra model and filtered-error structure. The computational complexity analysis shows that the proposed DVMFELMS algorithm can significantly reduce the complexity, especially for the NANC system with the NSP case. The simulation result shows that the proposed algorithm can achieve comparable performance with the VFELMS algorithm and other state-of-the-art nonlinear filters in simulation conditions, while the decomposable error of the Volterra kernel may inevitably be introduced. In addition, the proposed DVMFELMS algorithm shows potential in a better convergence property due to the fewer parameters used in each sub-filter. Further work should concentrate on studying the step control to improve the stability of the DVMFELMS algorithm for practical applications.