10.2.1 Problem Setup

Let us consider a generic network of N agents (e.g., sensors in a WSN) as the one depicted in Fig. 10.1. We assume that time is slotted and, at every time instant n, each agent receives a new observation $({\mathbf{u}}_{k,n},d_k(n))$, where ${\mathbf{u}}_{k,n}\in {\mathbb{R}}^M$ is the model input vector at agent k (e.g., a buffer of the last M samples) and $d_k(n)$ the corresponding desired response. For simplicity, we assume that $d_k(n)$ is a scalar. For the rest of the chapter, we shall use the subscript k to denote a quantity specific to one of the agents.

Following the standard supervised learning approach, the desired input/output relation can be modeled by choosing a function f in some hypothesis space $\mathcal{H}$. For simplicity, in this section we suppose that each function is parameterized by a vector of tunable parameters $\mathbf{w}\in {\mathbb{R}}^q$, e.g., a linear predictor.¹ With this setting, each agent is interested in finding a set of parameters ${\mathbf{w}}_k^{⁎}$ which minimizes some local cost function $J_k(\cdot )$ defined over the hypothesis space from streaming data. Specifically, for most estimation problems in practice, these local cost functions are defined as the expectation of some error function $L(\cdot ,\cdot )$ with respect to the statistics of the local stream of data,

$J_k({\mathbf{w}}_k)=\mathbb{E}\left\{L\right(d_k,f_k({\mathbf{u}}_k)\left)\right\},$

where we use the shorthand $f_k({\mathbf{u}}_k)=f({\mathbf{u}}_k;{\mathbf{w}}_k)$. The global optimization problem to be solved at the network level is then given by the sum of the local cost functions,

$\underset{{\mathbf{w}}_1,\dots ,{\mathbf{w}}_N\in {\mathbb{R}}^q}{\min }\{J_{\text{glob}}({\mathbf{w}}_1,\dots ,{\mathbf{w}}_N)\}=\sum _{k=1}^N{J}_k({\mathbf{w}}_k),$

where ${\mathbf{w}}_k$ is the estimate at the kth agent. If we assume that no relation holds between the local cost functions, then (10.2) reduces to a set of N optimization problems that can be solved in parallel by every agent, independently of all the others. A more interesting formulation arises by assuming some form of relation among the cost functions (detailed below). In this case, the information gathered by one agent during its optimization process can potentially be used by the other agents to speed up their convergence, or even converge to a better solution using some shared information.

The difficulty arises from the fact that each agent has direct access to its local cost function, but it has no access to the local cost functions of the other agents for all the reasons mentioned in the introduction. Depending on the relation between cost functions, we can distinguish between three classes of distributed problems:

Multitask problems can be further subdivided, depending on whether the similarity between tasks is known a priori, or whether it must be inferred from the data. An example of the former case is the algorithm in [18], while examples of the latter case can be found in [19,20]. Inferring knowledge about the groups might require the inclusion of some decentralized clustering procedure in the learning process, which is an interesting problem in its own right [29]. For simplicity, in this chapter we will focus on the multitask formulation, but we underline that almost all multitask algorithms can be generalized to handle the clustered multitask case; e.g., see [18].

10.2.2 Diffusion-Based Algorithms

In order to describe a family of algorithms to solve the previous problem, we first need to define a model of communication between the different agents. Most of the literature focuses on the case where the communication links form a static, undirected, connected graph $\mathcal{G}$. At each time step, the kth agent is allowed to communicate with its set of direct neighbors ${\mathcal{N}}_k$, while it cannot send messages to agents to which it is not directly linked.³ Nonetheless, the overall connectedness of the graph ensures that information can flow throughout the entire network. In this scenario, connectivity can be described by a symmetric, real-valued matrix $\mathbf{A}\in {\mathbb{R}}^{N\times N}$ such that $A_{kl}\ne 0$ only if agents k and l are connected and

$\sum _{k=1}^N{A}_{kl}=1,A_{kl}\ge 0\text{ for any }k,l=1,\dots ,N.$

These weights are used by the agents to scale and combine information received by their neighbors. The previous condition ensures that each row of the matrix defines a convex combination, so that the range of the information to be combined is always preserved (formally, the condition requires that A be left stochastic). There are several strategies allowing agents to build such matrices, as we show later. This formulation can also be extended in several ways, most notably with the use of asynchronous formulations [30] (thus avoiding the need for a common clock throughout the network) and mixing matrices that do not respect double stochasticity [31]. Nonetheless, since this chapter is only intended as an introduction, we will focus on the simpler case detailed before.

In the case of a single agent, (10.2) could be solved by a simple gradient descent algorithm. In order to counteract the lack of global information, the basic idea of diffusion algorithms is to interleave local optimization steps with communication steps, where each agent combines its own estimate with those of its neighbors. In the filtering literature, this strategy is generally denoted as adapt-then-combine (ATC):

${\mathit{\varphi }}_{k,n}={\mathbf{w}}_{k,n-1}-{\mu }_k\mathrm{\nabla }{J}_k({\mathbf{w}}_{k,n-1}),$

${\mathbf{w}}_{k,n}=\sum _{l=1}^N{A}_{lk}{\mathit{\varphi }}_{l,n},$

where ${\mu }_k$ is a (possibly time-dependent) step size and, similarly to before, we use a double subscript $(k,n)$ to denote the estimate of agent k at time n. Practically, the gradient term in (10.4) can be replaced with a noisy version, for example using an instantaneous approximation computed from the current data sample. A diffusion step example is given in Fig. 10.2.

These algorithms are particularly suitable in single-task scenarios, where their convergence properties in the convex case have been analyzed extensively [14,15]. Interestingly, they can still have good convergence properties in the multitask case, as shown in [19]. However, they provide a building block for all other formulations, as we show in Section 10.2.3. Before that, we describe an example of diffusion algorithm for nonlinear learning with a distributed logistic regression model.

10.2.2.1 An Example: Logistic Regression Over Networks

Consider a binary classification problem where $d_k(n)\in \{0,1\}$, i.e., each output is a single bit representing whether the corresponding input belongs to a certain class or not. We approximate the underlying relation using a logistic predictor $f(\mathbf{u})=\sigma ({\mathbf{w}}^T\mathbf{u})$, where $\sigma (\cdot )$ is the sigmoid function, as follows:

$\sigma (s)=\frac{1}{1+\exp \{-s\}},$

(10.6)

ensuring that the outputs of the model are properly scaled as valid probabilities. Each agent wishes to minimize the (regularized) expected cross-entropy over its stream of data:

$J_k(\mathbf{w})=\mathbb{E}\{-d_k\cdot \log (f_k({\mathbf{u}}_k))-(1-d_k)\cdot \log (1-f_k({\mathbf{u}}_k)\left)\right\}+\frac{\lambda }{2N}{\Vert {\mathbf{w}}_k\Vert }_2^2,$

(10.7)

where the factor $1/N$ in the regularization term ensures that the total penalization in (10.2), when summed over all agents, is equal to $\frac{\lambda }{2}$. By taking instantaneous approximations to the gradient, simple algebra manipulations show that the update steps in (10.4) are given by

${\mathit{\varphi }}_{k,n}={\mathbf{w}}_{k,n-1}+{\mu }_k(d_k(n)-f_{k,n-1}({\mathbf{u}}_{k,n})){\mathbf{u}}_{k,n}-\frac{1}{N}{\mu }_k\lambda {\mathbf{w}}_{k,n-1}.$

(10.8)

In order to show the speedup obtained by such procedure, in Fig. 10.3 we plot the average accuracy (see below) obtained with a network of 20 agents, whose connectivity is generated randomly, where at every iteration each agent receives a randomly chosen example taken from the well-known Wisconsin Breast Cancer Database (WBCD).⁴ The accuracy is defined as 1 if the agent makes a correct prediction (i.e., the sign of $f(\mathbf{u})$ agrees with d), 0 otherwise. It is computed before the adaptation step, and it is averaged with respect to the different agents and the different simulations.

10.2.3 Extension to Multitask Learning

The general ideas exposed in Section 10.2.2 can be easily extended in order to be more efficient in the multitask scenario. Here, we detail a simple extension originally proposed in [18] to show one example of such extensions. We refer to the large number of works cited in the introduction for more recent proposals.

Suppose that, given two agents k and l, we have a way to quantify the similarity among their respective minimizers. In order to leverage this information, we can augment the original cost function in (10.2) with a regularization term forcing the similarity among minimizers, in terms of their Euclidean distance, as follows:

$J^{\text{glob}}({\mathbf{w}}_1,\dots ,{\mathbf{w}}_N)=\sum _{k=1}^N{J}_k({\mathbf{w}}_k)+\eta \sum _{k=1}^N\sum _{l\ne k,l\in {\mathcal{N}}_k}{\rho }_{kl}{\Vert {\mathbf{w}}_k-{\mathbf{w}}_l\Vert }_2^2,$

where η is a regularization factor and the nonnegative coefficients ${\rho }_{kl}\ge 0$ quantify our a priori knowledge about the similarities. We assume that, for each agent, the weights are positive and sum to one. We have

$\sum _{l=1}^N{\rho }_{kl}=1\text{ and }{\rho }_{kl}=0\text{ if }l\notin {\mathcal{N}}_k,\forall k\in \{1,\dots ,N\}.$

As a consequence of their definition, these regularization factors mirror the communication network of the agents. Due to this, taking a local optimization step with respect to the estimate of the kth agent immediately requires a diffusion step. We have

${\mathbf{w}}_{k,n}={\mathbf{w}}_{k,n-1}-{\mu }_k\mathrm{\nabla }{J}_k({\mathbf{w}}_{k,n-1})-{\mu }_k\eta \sum _{l\ne k,l\in {\mathcal{N}}_k}\frac{({\rho }_{kl}+{\rho }_{lk})}{2}({\mathbf{w}}_{k,n-1}-{\mathbf{w}}_{l,n-1}).$

Since the estimates are already exchanged, the previous update step can be implemented without the need for additional combination steps like in Section 10.2.2. As an example, by considering a simple linear predictor $f_k(\mathbf{u})={\mathbf{w}}_k^T\mathbf{u}$ and instantaneous approximations to the gradient, we obtain the following update rule for the multitask diffusion LMS, presented in [18]:

${\mathbf{w}}_{k,n}={\mathbf{w}}_{k,n-1}+{\mu }_k(d_k(n)-{\mathbf{w}}_{k,n-1}^T{\mathbf{u}}_{k,n}){\mathbf{u}}_{k,n}-{\mu }_k\eta \sum _{l\ne k,l\in {\mathcal{N}}_k}\frac{({\rho }_{kl}+{\rho }_{lk})}{2}({\mathbf{w}}_{k,n-1}-{\mathbf{w}}_{l,n-1}).$

If we assume that the mixing weights are symmetric, $\frac{({\rho }_{kl}+{\rho }_{lk})}{2}$ simplifies to ${\rho }_{kl}$. It is possible to obtain asymmetric regularization terms by considering a game-theoretical formulation of the optimization problem; see the discussion in [18].

10.3.1 Expansion Over Random Bases

One immediate idea is to project the original input vector u to a high-dimensional space via some fixed function $\mathbf{h}(\mathbf{x}):{\mathbb{R}}^M\to {\mathbb{R}}^B$ before using it with a linear predictor, where d is the dimensionality of the input vector u and B is a parameter which (in general) can be chosen by the user. In the distributed case, this requires only a small communication overhead in the beginning for the agents to agree on a specific projection function. Any distributed linear algorithm, such as the diffusion LMS or the diffusion RLS, can then be used.

Generally speaking, deterministic mappings (such as those mentioned in Chapters 2 and 4) are not efficient, because their size might grow exponentially with respect to M. A different idea is to use basis functions whose parameters are assigned stochastically, e.g., a parameterized sigmoid,

$h_i(\mathbf{u})=\frac{1}{1+\exp \{-{\mathbf{a}}_i^T\mathbf{u}-b_i\}},$

where ${\mathbf{a}}_i$ and $b_i$ might be extracted randomly from some uniform distribution (whose range is generally chosen in order to provide a good accuracy; see the discussion in [32]). Interestingly, it is possible to show that the resulting estimator (called a random vector functional-link network) is a universal approximator over compact functions provided that B is chosen large enough [33]. It is also possible to interpret it as a degenerate case of the echo state network described in Chapter 12, where connections between different nodes have been removed. The idea of using RVFL networks in a distributed context was proposed in [34] for the batch case and in [35] for the online case with DF algorithms.

A different approach is to design a feature mapping $\mathbf{h}(\cdot )$ approximating a specific kernel $\mathcal{K}(\cdot ,\cdot )$ function⁵ chosen by the user:

$\mathcal{K}({\mathbf{u}}_1,{\mathbf{u}}_2)\approx \langle \mathbf{h}({\mathbf{u}}_1),\mathbf{h}({\mathbf{u}}_2)\rangle .$

This idea was popularized by [36] for approximating shift-invariant kernels (e.g., the Gaussian kernel) in large-scale applications of kernel methods. In particular, it is possible to show that this class of kernels can be easily approximated with very simple stochastic mappings. The work [37] was the first to apply this idea explicitly to kernel filters, and similar algorithms were independently reintroduced in [38]. Since Chapter 7 is entirely devoted to this idea, we will not go further into it. We refer the interested reader to [32] for a recent overview on random feature methods.

10.3.2 Distributed Kernel Filters

An alternative line of research is devoted to distributed strategies for kernel filters, working directly on some reproducing kernel Hilbert space (RKHS), instead of approximating the kernel function as in Section 10.3.1. As we stated in the introduction, several distributed algorithms for kernel ridge regression were devised in the context of WSNs [4], followed by algorithms for the distributed optimization of SVMs [39,7]. Any approach to dealing with kernels faces the challenge of working with a kernel-based model that depends explicitly on all the data in the training set. A naive distributed implementation would thus require to exchange all the local datasets between the agents, which can become infeasible.

In an online context, this is made worse by the growing nature of the kernel model [40]. This is a fundamental drawback underlying any kernel filter algorithm [41–43]. An initial investigation in developing a fully distributed version of the kernel LMS (KLMS) was made in [44], where the basic idea is to consider diffusion algorithms directly in a functional form. In particular, let us assume that the data received from the kth agent satisfies a model of the following form:

$d_k(n)={\psi }_k^o({\mathbf{u}}_{k,n})+{\nu }_k(n),$

where ${\psi }_k^o$ belongs to an RKHS $\mathcal{H}$, while ${\nu }_k(n)$ is a zero mean white noise with variance ${\sigma }_k^2$. Restricting our attention to a generic single-task network, we have

${\psi }_k^o={\psi }^o\forall k\in \{1,\dots ,N\}.$

Considering the classical squared error function, the gradient of the local cost functions can now be computed in terms of their Fréchet derivatives as⁶

$\mathrm{\nabla }{J}_k({\psi }_k)=-2\mathbb{E}\left\{\right(d_k-{\psi }_k({\mathbf{u}}_k))\kappa (\cdot ,{\mathbf{u}}_k)\},$

where κ is the kernel function associated to the RKHS. Considering instantaneous approximations for the expectation as was done earlier, we arrive at a functional equivalent of the ATC diffusion framework,

${\delta }_{k,n}={\mathit{\psi }}_{k,n-1}+{\mu }_k(d_k(n)-{\psi }_{k,n-1}({\mathbf{u}}_{k,n}))\kappa (\cdot ,{\mathbf{u}}_{k,n}),$

${\psi }_{k,n}=\sum _{l=1}^N{A}_{lk}{\delta }_{l,n}.$

Although this formulation is extremely general, one has still to solve the problem of the growing structure of the kernel functions. The idea pursued in [44] is to assume some shared dictionary $\mathcal{D}$ among nodes, whose selection is (at the moment) an open research question. Using this approximation, we can rewrite the desired function as

${\psi }_{k,n}={\mathit{\beta }}_{k,n}^T{\mathbf{k}}_{k,n},$

where ${\mathbf{k}}_{k,n}$ is the vector of kernel values computed between the current input vector ${\mathbf{u}}_{k,n}$ and the shared dictionary $\mathcal{D}$. Each function ${\psi }_{k,n}$ is now parameterized by the set of linear coefficients ${\mathit{\beta }}_{k,n}$. The previous algorithm can be rewritten as⁷

${\mathit{\delta }}_{k,n}={\mathit{\beta }}_{k,n-1}+{\mu }_k(d_k(n)-{\mathit{\beta }}_{k,n-1}^T{\mathbf{k}}_{k,n})){\mathbf{k}}_{k,n},$

${\mathit{\beta }}_{k,n}=\sum _{l=1}^N{A}_{lk}{\mathit{\delta }}_{l,n}.$

The idea of preselecting a dictionary is not new in the kernel literature. In fact, one of the earliest algorithms for distributed SVMs [39] exploited a similar idea, which is termed semiparametric SVM. In [47], a fixed dictionary is used to analyze the convergence behavior of the KLMS algorithm. A derivation of the functional diffusion KLMS algorithm when removing the fixed dictionary constraint is given in [48]. Another extension is presented in [49], where a set of consensus constraints is included in the problem to ensure convergence and speed up the algorithm.

10.3.3 Diffusion Spline Filters

Another possibility for nonlinear learning over networks is given by considering spline adaptive filters (SAFs).⁸ The idea of using SAFs in a distributed environment was recently introduced in [50]. In the following we briefly describe the distributed algorithm. The interested readers can refer to [51,52] for introductory material on the SAF model.

Let us assume that the data are generated according to a restricted Wiener model given by

$d_k(n)=f_k^o\left({\mathbf{w}}_k^T{\mathbf{u}}_{k,n}\right)+{\nu }_k(n),$

where $f_k^o$ is any smooth nonlinear function and ${\nu }_k(n)$ is a noise term. A SAF mimics this architecture, where the nonlinear term is approximated via spline interpolation over a set of Q fixed control points that are adapted during learning. Hence, in a distributed scenario each agent has estimates of the local part of the filter, ${\mathbf{w}}_{k,n}$, and of the aforementioned control points, ${\mathbf{q}}_{k,n}$, as shown schematically in Fig. 10.4.

Consider a single-task scenario, where each agent tries to minimize the expected squared loss. Following [50], we consider a combine-then-adapt (CTA) scheme, where the combination is performed before the adaptation. The two steps are applied to both sets of parameters ${\mathbf{w}}_{k,n}$ and ${\mathbf{q}}_{k,n}$ simultaneously. However, by exploiting the SAF structure we can avoid exchanging the full weight vector ${\mathbf{q}}_{k,n}$, as described in the following.

The combination step starts with the agents exchanging their current estimates of the linear weights as

${\mathit{\psi }}_{k,n-1}=\sum _{l\in {\mathcal{N}}_k}{A}_{lk}{\mathbf{w}}_{l,n-1}.$

The new weights are used to compute the output of the linear part of the filter, denoted as $s_k(n)={\mathit{\psi }}_{k,n-1}^T{\mathbf{u}}_{k,n}$. We use i to denote the index of the closest control point to $s_k(n)$ in our set of fixed control points. As described in Chapter 3, the final output of a Wiener SAF depends only on the ith control point and its P right neighbors, with P being the order of interpolation. Let us denote by ${\mathbf{q}}_{i,k,n-1}$ the set of such ‘active’ control points for agent k, which are called the ‘span’ of the filter (see Chapter 3 for more details). We use a third subscript to denote dependence with respect to the span. The second combination step is performed only with respect to the current span:

${\mathit{\xi }}_{k,n-1}=\sum _{l\in {\mathcal{N}}_k}{A}_{lk}{\mathbf{q}}_{i,l,n-1}.$

In the case of cubic interpolation, each ${\mathit{\xi }}_{k,n-1}$ has dimensionality 4, making its exchange extremely efficient, with only a fixed overhead with respect to a classical diffusion LMS. Practically, every agent sends its current span index i to its neighbors and receives back the vectors ${\mathbf{q}}_{i,l,n-1}$. For simplicity, the mixing weights $A_{lk}$ in the two diffusion steps are assumed identical.

Next, we proceed to the adaptation step. The complete SAF output given the new span is obtained (again following the general rules of Chapter 5) as

$y_k(n)={\mathbf{u}}^T\mathbf{B}{\mathit{\xi }}_{k,n-1},$

where the vector u is constructed by taking powers up to a fixed order of the normalized value $\frac{s_k(n)}{\mathrm{\Delta }x}-\lfloor \frac{s_k(n)}{\mathrm{\Delta }x}\rfloor$, where Δx is the sampling precision of the spline, and B is the spline matrix, e.g., the Catmull-Rom spline given by

$\mathbf{B}=\frac{1}{2}\left[\begin{array}{cccc}\hfill -1\hfill & \hfill 3\hfill & \hfill -3\hfill & \hfill 1\hfill \\ \hfill 2\hfill & \hfill -5\hfill & \hfill 4\hfill & \hfill -1\hfill \\ \hfill -1\hfill & \hfill 0\hfill & \hfill 1\hfill & \hfill 0\hfill \\ \hfill 0\hfill & \hfill 2\hfill & \hfill 0\hfill & \hfill 0\hfill \end{array}\right].$

Adaptation is carried out by performing two parallel gradient descent steps:

${\mathbf{w}}_{k,n}={\mathit{\psi }}_{k,n-1}+{\mu }_k{e}_{k,n}{\phi }^{\prime }(s_k(n)){\mathbf{u}}_{k,n},$

${\mathbf{q}}_{i,k,n}={\mathit{\xi }}_{k,n-1}+{\mu }_k{e}_{k,n}{\mathbf{B}}^T\mathbf{u},$

where $e_{k,n}$ is the instantaneous local error and ${\phi }^{\prime }(s_k(n))$ is the spline derivative with respect to the linear weights. Note that the diffusion LMS can be obtained as a special case, where each node initializes its nonlinearity as the identity, and the step size of the nonlinear part is set to zero.

10.5.1 Experiment Setup

In this section, we evaluate the proposed method on a simulated multitask nonlinear problem. The output at each agent is given by the following equation:

$d_k(n)=f({\mathbf{u}}_{k,n})+{({\mathbf{w}}_0+{\mathbf{w}}_k)}^T{\mathbf{u}}_{k,n}+{\nu }_k(n),$

which is composed of a common nonlinear part $f(\cdot )$, a common linear term with weight vector ${\mathbf{w}}_0$, a local linear part ${\mathbf{w}}_k^T{\mathbf{u}}_{k,n}$ and a local noise of variance ${\sigma }_k^2$. In particular, we considered a three dimensional input vector $\mathbf{u}={[u_1,u_2,u_3]}^T$, with the following nonlinearity:

$f(\mathbf{u})=a{u}_1^2+b{u}_2{u}_3,$

where a and b were generated from a normal distribution, similarly to the local and shared coefficient vectors ${\mathbf{w}}_k$. Noise variances were generated uniformly for each agent in the interval $[0,0.3]$. We added an additional level of diversity over the network by randomly assigning the learning rates to the agents from the uniform distribution over the interval $[0,0.1]$. We considered a network of 9 agents, whose connectivity was randomly assigned such that each agent is connected in average with one-fifth of the other agents, with the requirement that the overall graph is connected. The resulting network connectivity, an example of desired output and a plot of the noise variances and learning rates are all shown in Fig. 10.5.

We trained the network over a sequence of 1000 time instants, with white Gaussian inputs with zero mean and unitary variance. The mixing matrix was chosen according to the max-degree heuristic:

$A_{lk}=\{\begin{array}{cc}\frac{1}{{\text{deg}}_{\max }+1},\hfill & \text{ if}\mathit{l}\text{is connected to}\mathit{k}\text{, }\hfill \\ 1-\frac{{\text{deg}}_k}{{\text{deg}}_{\max }+1},\hfill & \text{ if }k=l,\hfill \\ 0,\hfill & \text{ otherwise,}\hfill \end{array}$

where ${\text{deg}}_k$ is the degree of node k and ${\text{deg}}_{\max }$ is the maximum degree of the network.⁹ Each experiment was averaged over 500 different runs, by keeping fixed the assignments shown in Fig. 10.5.

10.5.2 Results and Discussion

We compared the performance of a standard diffusion LMS (D-LMS), a multitask D-LMS as described in Section 10.2.3 (D-MT-LMS), the diffusion KLMS described in Section 10.3.2 and the proposed multitask D-KLMS introduced in Section 10.4 (D-MT-KLMS). For the kernel algorithms, we used a Gaussian kernel,

$\mathcal{K}({\mathbf{u}}_1,{\mathbf{u}}_2)=\exp \{-\gamma {\Vert {\mathbf{u}}_1-{\mathbf{u}}_2\Vert }_2^2\},$

where γ was chosen as the inverse of the dimensionality of u, which was found to provide a good accuracy. For the multitask algorithms, the regularization coefficients were selected uniformly as

${\rho }_{kl}=\{\begin{array}{cc}\frac{1}{{\text{deg}}_k},\hfill & \text{ if}\mathit{k}\text{is connected to}\mathit{l}\text{, }\hfill \\ 0,\hfill & \text{ otherwise,}\hfill \end{array}$

while the regularization factor was set to $\eta =0.01$. For the kernel algorithms, we fixed a priori a dataset of size 100 with randomly extracted elements. The average MSE in dB across all runs is shown in Fig. 10.6.

As expected, the D-LMS was the poorest performing algorithm, due to the doubly incorrect assumptions that the agents share the same minimizer and that the underlying function is linear. By relaxing one of the two assumptions, D-MT-LMS performed better, with an accuracy that is slightly inferior to D-KLMS. Clearly, D-MT-KLMS was the best algorithm in this case, showing that it can be an effective solution for nonlinear multitask problems.

In Fig. 10.7 we show the MSE evolution for three representative agents. As expected, their performance is different depending on the selected learning rate and amount of noise, but the multitask algorithm is able to effectively combine the learning curves to obtain the average behavior as in the purple (darkest gray in print version) line of Fig. 10.6. Finally, in Fig. 10.8 we show the average MSE evolution when varying the size of the dictionary. Increasing the size improves the accuracy (up to a given upper bound), at the cost of a larger computational burden.