Distributed Submodular Minimization via Block-Wise Updates and Communications

TL;DR

This paper introduces a distributed algorithm for submodular minimization that enables networked agents to collaboratively solve the problem while preserving privacy, using block-wise updates and communication based on Lovász extensions.

Contribution

It presents a novel distributed algorithm employing block-wise updates and Lovász extensions for submodular minimization without central coordination.

Findings

Algorithm converges in expectation to the optimal solution.

Agents successfully perform distributed image segmentation.

Reduced computational burden through block-wise greedy updates.

Abstract

In this paper we deal with a network of computing agents with local processing and neighboring communication capabilities that aim at solving (without any central unit) a submodular optimization problem. The cost function is the sum of many local submodular functions and each agent in the network has access to one function in the sum only. In this \emph{distributed} set-up, in order to preserve their own privacy, agents communicate with neighbors but do not share their local cost functions. We propose a distributed algorithm in which agents resort to the Lov\`{a}sz extension of their local submodular functions and perform local updates and communications in terms of single blocks of the entire optimization variable. Updates are performed by means of a greedy algorithm which is run only until the selected block is computed, thus resulting in a reduced computational burden. The proposed algorithm is shown to converge in expected value to the optimal cost of the problem, and an approximate solution to the submodular problem is retrieved by a thresholding operation. As an application, we consider a distributed image segmentation problem in which each agent has access only to a portion of the entire image. While agents cannot segment the entire image on their own, they correctly complete the task by cooperating through the proposed distributed algorithm.

Equations

$${\mathrm{minimize}}_{X\subseteq V}$$

$${\mathrm{minimize}}_{x\in [0,1{]}^n}$$

$$X^{\star }=\{\ell \mid x_{\ell }^{\star }>\tau \}.$$

$$\{m_1,\dots ,m_{p-1},m_p=\ell \}=\text{textsc}PartialSort(y)$$

$$g_{i,\ell }=\{\begin{array}{ll}{F}_i(\{\ell \}),& \text{if }p=1\\ F_i(\{m_1\dots m_{p-1},\ell \})-F_i(\{m_1\dots m_{p-1}\}),& \text{otherwise}\end{array}$$

$$x_{j,\ell }^k{\mid }_i=\{\begin{array}{ll}{x}_{j,\ell }^k,& \text{if }\ell ={\ell }_j^{k-1}\\ x_{j,\ell }^{k-1}{\mid }_i,& \text{otherwise}\end{array}$$

$$y_i^k=\sum _{j\in {\mathcal{N}}_i^{\text{in}}}{w}_{ij}{x}_j^k{\mid }_i$$

$$g_{i,{\ell }_i^k}^k=\text{textsc}BlockGreedy(y_i^k,{\ell }_i^k)$$

$$x_{i,\ell }^{k+1}=\{\begin{array}{ll}{\Pi }_{[0,1]}\left[x_{i,{\ell }_i^k}^k-{\alpha }_i^k{g}_{i,{\ell }_i^k}^k\right]& \text{if }\ell ={\ell }_i^k\\ x_{i,\ell }^k& \text{otherwise}\end{array}$$

$$X_i^{\text{end}}=\{\ell \mid x_{i,\ell }^K>\tau \}$$

$$\sum _{k=0}^{\infty }{\alpha }_i^k=\infty ,\sum _{k=0}^{\infty }({\alpha }_i^k{)}^2<\infty ,{\alpha }_i^{k+1}\le {\alpha }_i^k$$

$$\underset{k\to \infty }{\lim }\mathbb{E}[\Vert x_i^k-{\bar{x}}^k\Vert ]=0,$$

$$\underset{k\to \infty }{\lim }{f}_{best}(x_i^k)=f(x^{\star }),$$

$$a_{p,q}=e^{-\frac{(I_p-I_q{)}^2}{2{\sigma }^2}},$$

$$a_{s,p}=$$

$$a_{p,t}=$$

$$a_{p,q}^i$$

$$a_{s,p}^i$$

$$a_{p,t}^i$$

$$F_i(X)=\sum _{\begin{array}{c}p\in X\\ q\in V\setminus X\end{array}}{a}_{p,q}^i+\sum _{q\in V\setminus X}{a}_{s,q}^i+\sum _{p\in X}{a}_{p,t}^i-\sum _{q\in V}{a}_{s,q}^i.$$

$${\mathrm{minimize}}_{X\subseteq V}\sum _{i=1}^N\left(\sum _{\begin{array}{c}p\in X\\ q\in V\setminus X\end{array}}{a}_{p,q}^i+\sum _{q\in V\setminus X}{a}_{s,q}^i+\sum _{p\in X}{a}_{p,t}^i-\sum _{q\in V}{a}_{s,q}^i\right).$$

Full text

1 Introduction

Many combinatorial problems in machine learning can be cast as the minimization of submodular functions (i.e., set functions that exhibit a diminishing marginal returns property). Applications include isotonic regression, image segmentation and reconstruction, and semi-supervised clustering (see, e.g., [1]).

In this paper we consider the problem of minimizing in a distributed fashion (without any central unit) the sum of $N\in{\mathbb{N}}$ submodular functions, i.e.,

[TABLE]

where $V=\{1,\ldots,n\}$ is called the ground set and the functions $F_{i}$ are submodular.

We consider a scenario in which problem (1) is to be solved by $N$ peer agents communicating locally and performing local computations. The communication is modeled as a directed graph $\mathcal{G}=(\mathcal{V},\mathcal{E})$, where $\mathcal{V}=\{1,\ldots,N\}$ is the set of agents and $\mathcal{E}\subseteq\mathcal{V}\times\mathcal{V}$ is the set of directed edges in the graph. Each agent $i$ receives information only from its in-neighbors, i.e., agents $j\in\mathcal{N}_{i}^{\text{in}}\triangleq\{j\mid(j,i)\in\mathcal{E}\}\cup\{i\}$, while it sends messages only to its out-neighbors $j\in\mathcal{N}_{i}^{\text{out}}\triangleq\{j\mid(i,j)\in\mathcal{E}\}\cup\{i\}$, where we have included agent $i$ itself in these sets. In this set-up, each agent knows only a portion of the entire optimization problem. Namely, agent $i$, knows the function $F_{i}(X)$ and the set $V$ only. Moreover, the local functions $F_{i}$ must be maintained private by each agent and cannot be shared.

In order to give an insight on how the proposed scenario arises, let us introduce the distributed image segmentation problem that we will consider later on as a numerical example. Given a certain image to segment, the ground set $V$ consists of the pixels of such an image. We consider a scenario in which each of the $N$ agents in the network has access to only a portion $V_{i}\subseteq V$ of the image. In Figure 1 a concept with the associated communication graph is shown. Given $V_{i}$, the local submodular functions $F_{i}$ are constructed by using some locally retrieved information, like pixel intensities. While agents do not want to share any information on how they compute local pixel intensities (due to, e.g., local proprietary algorithms), their common goal is to correctly segment the entire image.

Such a distributed set-up is motivated by the modern organization of data and computational power. It is extremely common for computational units to be connected in networks, sharing some resources, while keeping other private, see, e.g., [2, 3]. Thus, distributed algorithms in which agents do not need to disclose their own private data will represent a novel disruptive technology. This paradigm has received significant attention in the last decade in the area of control and signal processing, [4, 5].

Related work

Submodular minimization problems can be mainly addressed in two ways. On the one hand, a number of combinatorial algorithms have been proposed [6, 7], some based on graph-cut algorithms [8] or relying on problems with a particular structure [9]. On the other hand, convex optimization techniques can be exploited to face submodular minimization problems by resorting the so called Lovàsz extension. Many specialized algorithms have been developed in the last years by building on the particular properties of submodular functions (see [1] and reference therein). In this paper we focus on the problem of minimizing the sum of many submodular functions, which has received attention in many works [10, 9, 11, 12, 13]. In particular, centralized algorithms have been proposed based on smoothed convex minimization [10] or alternating projections and splitting methods [11], whose convergence rate is studied in [13]. This problem structure typically arises, for example, in Markov Random Fields (MRF) Maximum a-Posteriori (MAP) problems [14, 12], a notable example of which is image segmentation.

While a vast literature on distributed continuous optimization has been developed in the last years (see, e.g., [15]), distributed approaches for tackling (submodular) combinatorial optimization problems started to appear only recently. Submodular maximization problems have been treated and approximately solved in a distributed way in several works  [16, 17, 18, 19, 20, 21]. In particular, distributed submodular maximization subject to matroid constraints is addressed in [19, 20], while in [21], the authors handle the design of communication structures maximizing the worst case efficiency of the well-known greedy algorithm for submodular maximization when applied over networks. Regarding distributed algorithms for submodular minimization problems, they have not received much attention yet. In [22] a distributed subgradient method is proposed, while in [23] a greedy column generation algorithm is given. All these approaches involve the communication/update of the entire decision variable at each time instant. This can be an issue when the decision variable is extremely large. Thus, block-wise approaches like those proposed in [24] should be explored.

Contribution and organization

The main contribution of this paper is the MIxing bloCKs and grEedY (MICKY) method, i.e., a distributed block-wise algorithm for solving problem (1). At any iteration, each agent computes a weighted average on local copies of neighbors solution estimates. Then, it selects a random block and performs an ad-hoc (block-wise) greedy algorithm (based on the one in [1, Section 3.2]) until the selected block is updated. Finally, based on the output of the greedy algorithm, the selected block of the local solution estimate is updated and broadcast to the out-neighbors. The proposed algorithm is shown to produce cost-optimal solutions in expected value by showing that it is an instance of the Distributed Block Proximal Method presented in [25]. In fact, the partial greedy algorithm performed on the local submodular cost function $F_{i}$ is shown to compute a block of a subgradient of its Lovàsz extension.

A key property of this algorithm is that each agent is required to update and transmit only one block of its solution estimate. In fact, it is quite common for networks to have communication bandwidth restrictions. In these cases the entire state variable may not fit the communication channels and, thus, standard distributed optimization algorithms cannot be applied. Furthermore, the greedy algorithm can be very time consuming when an oracle for evaluating the submodular functions is not available and, hence, halting it earlier can reduce the computational load.

The paper is organized as follows. The distributed algorithm is presented and analyzed in Section 2, and it is tested on a distributed image segmentation problem in Section 3.

Notation and definitions

Given a vector $x\in\mathbb{R}^{n}$, we denote by $x_{\ell}$ the $\ell$-th entry of $x$. Let $V$ be a finite, non-empty set with cardinality $|V|$. We denote by $2^{V}$ the set of all its $2^{|V|}$ subsets. Given a set $X\subseteq V$, we denote by $\mathbf{1}_{X}\in{\mathbb{R}}^{|V|}$ its indicator vector, defined as $\mathbf{1}_{X_{\ell}}=1$ if $\ell\in X$, and [math] if $\ell\not\in X$. A set function $F:2^{V}\to\mathbb{R}$ is said to be submodular if it exhibits the diminishing marginal returns property, i.e., for all $A,B\subseteq V$, $A\subseteq B$ and for all $j\in V\setminus B$, it holds that $F(A\cup\{j\})-F(A)\geq F(B\cup\{j\})-F(B)$. In the following we assume $F(X)<\infty$ for all $X\subseteq V$ and, without loss of generality, $F(\emptyset)=0$. Given a submodular function $F:2^{V}\to\mathbb{R}$, we define the associated base polyhedron as $\mathcal{B}(F):=\{w\in{\mathbb{R}}^{n}\mid\sum_{\ell\in X}w_{\ell}\leq F(X)\;\forall X\in 2^{V},\;\sum_{\ell\in V}w_{\ell}=F(V)\}$ and by $f(x)=\max_{w\in\mathcal{B}(F)}w^{\top}x$ the Lovàsz extension of $F$.

2 Distributed algorithm

2.1 Algorithm description

In order to describe the proposed algorithm, let us introduce the following nonsmooth convex optimization problem

[TABLE]

where $f_{i}(x):\mathbb{R}^{n}\to\mathbb{R}$ is the Lovàsz extension of $F_{i}$ for all $i\in\{1,\ldots,N\}$. It can be shown that solving problem (2) is equivalent to solving problem (1) (see, e.g., [26] and [1, Proposition 3.7]). In fact, given a solution $x^{\star}$ to problem (2), a solution $X^{\star}$ to problem (1) can be retrieved by thresholding the components of $x^{\star}$ at an arbitrary $\tau\in[0,1]$ (see [27, Theorem 4]), i.e.,

[TABLE]

Notice that, given $F_{i}$ in problem (1), each agent $i$ in the network is able to compute $f_{i}$, thus, in the considered distributed set-up, problem (2) can be addressed in place of problem (1). Moreover, since $F_{i}$ is submodular for all $i$, then $f_{i}$ is a continuous, piece-wise affine, nonsmooth convex function, see, e.g., [1].

In order to compute a single block of a subgradient of $f_{i}$, each agent $i$ is equipped with a local routine (reported next), that we call BlockGreedy and that resembles a local (block-wise) version of the greedy algorithm in [1, Section 3.2]. This routine takes as inputs a vector $y$ and the required block $\ell$, and returns the $\ell$-th block of a subgradient $g_{i}$ of $f_{i}$ at $y$. For the sake of simplicity, suppose $l$ is a single component block. Moreover, assume to have a routine PartialSort that generates an ordering $\{m_{1},\ldots,m_{p}\}$ such that $y_{m_{1}}\geq\ldots\geq y_{m_{p}}$, $m_{p}=\ell$ and $y_{r}\leq y_{\ell}$ for each $r\in\{1,\ldots,n\}\setminus\{m_{1},\ldots,m_{p}\}$. Then, the BlockGreedy algorithm reads as follows.

The MICKY algorithm works as follows. Each agent stores a local solution estimate $x_{i}^{k}$ of problem (2) and, for each in-neighbor $j\in\mathcal{N}_{i}^{\text{in}}$, a local copy of the corresponding solution estimate $x_{j}^{k}{\mid}_{i}$. At the beginning, each node selects the initial condition $x_{i}^{0}$ at random in $[0,1]^{n}$ and shares it with its out-neighbors. We associate to the communication graph $\mathcal{G}$ a weighted adjacency matrix $\mathcal{W}\in\mathbb{R}^{N\times N}$ and we denote with $w_{ij}=[\mathcal{W}]_{ij}$ the weight associated to the edge $(j,i)$. At each iteration $k$, agent $i$ performs three tasks:

1. (i)

it computes a weighted average $y_{i}^{k}=\sum_{j\in\mathcal{N}_{i}^{\text{in}}}w_{ij}x_{j}^{k}{\mid}_{i}$; 2. (ii)

it picks randomly (with arbitrary probabilities bounded away from [math]) a block $\ell_{i}^{k}\in\{1,\ldots,n\}$ and performs the BlockGreedy$(y_{i}^{k},\ell_{i}^{k})$; 3. (iii)

it updates $x_{i,\ell_{i}^{k}}^{k+1}$ according to (7), where $\Pi_{[0,1]}[\cdot]$ is the projector on the set $[0,1]$ and $\alpha_{i}^{k}\in(0,1)$, and broadcasts it to its out-neighbors $j\in\mathcal{N}_{i}^{\text{out}}$.

Agents halt the algorithm after $K>0$ iterations and recover the local estimates $X_{i}^{\text{end}}$ of the set solution to problem (1) by thresholding the value of $x_{i}^{K}$ as in (3). Notice that, in order to avoid to introduce additional notation, we have assumed each block of the optimization variable to be scalar (so that blocks are selected in $\{1,\ldots,n\}$). However, blocks of arbitrary sizes can be used (as shown in the subsequent analysis). A pseudocode of the proposed algorithm is reported in the next table.

2.2 Discussion

The proposed algorithm possesses many interesting features. Its distributed nature requires agents to communicate only with their direct neighbors, without resorting to multi-hop communications. Moreover, all the local computations involve locally defined quantities only. In fact, stepsize sequences and block drawing probabilities are locally defined at each node.

Regarding the block-wise updates and communications, they bring benefits in two areas. Communicating single blocks of the optimization variable, instead of the entire one, can significantly reduce the communication bandwidth required by each agent in broadcasting their local estimates. This makes the proposed algorithm implementable in networks with communication bandwidth restrictions. Moreover, the classical greedy algorithm requires to evaluate $|V|$ times the submodular function in order to produce a subgradient. When $|V|$ is very high and an oracle for evaluating functions $F_{i}$ is not available, this can be a very time consuming task. For example, in the example application in Section 3, we will resort to the minimum graph cut problem. Evaluating the value of a cut for a graph in which $E\subseteq V\times V$ is the set of arcs, requires a running-time $O(|E|)$. In the BlockGreedy routine, in contrast with what happens in the standard greedy routine, the sorting operation is (possibly) performed only on a part of the entire vector $y$, i.e., until the $\ell$-th component has been sorted. Thus, our routine evaluates the $\ell$-th component of the subgradient in at most two evaluations of the submodular function.

2.3 Analysis

In order to state the convergence properties of the proposed algorithm, let us make the following two assumptions on the communication graph and the associated weighted adjacency matrix $\mathcal{W}$.

Assumption 1** (Strongly connected graph).**

The digraph $\mathcal{G}=(\mathcal{V},\mathcal{E},\mathcal{W})$ is strongly connected. $\square$

Assumption 2** (Doubly stochastic weight matrix).**

For all $i,j\in\mathcal{V}$, the weights $w_{ij}$ of the weight matrix $\mathcal{W}$ satisfy

1. (i)

if $i\neq j$, $w_{ij}>0$ if and only if $j\in\mathcal{N}_{i}^{\text{in}}$; 2. (ii)

there exists a constant $\eta>0$ such that $w_{ii}\geq\eta$ and if $w_{ij}>0$, then $w_{ij}\geq\eta$; 3. (iii)

$\sum_{j=1}^{N}w_{ij}=1$* and $\sum_{i=1}^{N}w_{ij}=1$. *$\square$

The above two assumptions are very common when designing distributed optimization algorithms. In particular, Assumption 1 guarantees that the information is spread through the entire network, while Assumption 2 assures that each agent gives sufficient weight to the information coming from its in-neighbors.

Let $\bar{x}^{k}\triangleq\frac{1}{N}\sum_{i=1}^{N}x_{i}^{k}$ be the average over the agents of the local solution estimates at iteration $k$ and define $f_{best}(x_{i}^{k})\triangleq\min_{r\leq k}\mathbb{E}[f(x_{i}^{r})]$. Then, in the next result, we show that by cooperating through the proposed algorithm all the agents agree on a common solution and the produced sequences $\{x_{i}^{t}\}$ are asymptotically cost optimal in expected value when $K\to\infty$.

Theorem 1**.**

Let Assumptions 1 and 2 hold and let $\{x_{i}^{k}\}_{k\geq 0}$ be the sequences generated through the MICKY algorithm. Then, if the sequences $\{\alpha_{i}^{k}\}$ satisfy

[TABLE]

for all $k$ and all $i\in\mathcal{V}$, it holds that,

[TABLE]

and

[TABLE]

being $x^{\star}$ the optimal solution to (2).

Proof.

By using the same arguments used in [25, Lemma 3.1], it can be shown that $x_{j}^{k}{\mid}_{i}=x_{j}^{k}$ for all $k$ and all $i,j\in\mathcal{V}$. Then (10) follows from [25, Lemma 5.11]. Moreover, as anticipated, it can be shown that $g_{i,\ell_{i}^{k}}^{k}$ is the $\ell_{i}^{k}$-th block of a subgradient of the function $f_{i}(x)$ in problem (2) (see, e.g., [1, Section 3.2]). In fact, being $f_{i}$ defined as the support function of the base polyhedron $\mathcal{B}(F_{i})$, i.e., $f_{i}(x)=\max_{w\in\mathcal{B}(F_{i})}w^{\top}x$, the greedy algorithm [1, Section 3.2] iteratively computes a subgradient of $f_{i}$ component by component. Moreover, subgradients of $f_{i}$ are bounded by some constant $G<\infty$, since every component of a subgradient of $f_{i}$ is computed as the difference of $F_{i}$ over two different subsets of $V$. Given that, the proposed algorithm can be seen as a special instance of the Distributed Block Proximal Method in [25]. Thus, since Assumptions 1 and 2 holds, it inherits all the convergence properties of the Distributed Block Proximal Method and under the assumption of diminishing stepsizes (9) respectively, the result in (11) follows (see [25, Theorem 5.15]). $\square$∎

Notice that the result in Theorem 1 does not say anything about the convergence of the sequences $\{x_{i}^{k}\}$, but only states that if diminishing stepsizes are employed, asymptotically these sequences are consensual and cost optimal in expected value.

Despite that, from a practical point of view, two facts typically happen. First, agents approach consensus, i.e., for all $i\in\{1,\ldots,N\}$, the value $\|x_{i}^{k}-\bar{x}^{k}\|$ becomes small, extremely fast, so that they all agree on a common solution. Second, if the number of iterations $K$ in the algorithm is sufficiently large, the value of $x_{i}^{K}$ is a good solution to problem (2). Then, given $x_{i}^{K}$, each agent can reconstruct a set solution to problem (1) by using (8) and, in order to obtain the same solution for all the agents, we consider a unique threshold value, known to all the agents, $\tau\in[0,1]$.

Remark 2.1**.**

Notice that, by resorting to classical arguments, it can be easily shown from the analysis in [25] that the convergence rate of $f_{best}$ in Theorem 1 is sublinear (with explicit rate depending on the actual stepsize sequence). Moreover, if constant stepsizes are employed, convergence of $f_{best}$ to the optimal solution is attained in expected value with a constant error with rate $O(1/k)$ [25, Theorem 2].

3 Cooperative image segmentation

Submodular minimization has been widely applied to computer vision problems as image classification, segmentation and reconstruction, see, e.g., [10, 11, 28]. In this section, we consider a binary image segmentation problem in which $N=8$ agents have to cooperate in order to separate an object from the background in an image of size $D\times D$ pixels (with $D=64$). Each agent has access only to a portion of the entire image, see Figure 2, and can communicate according to the graph reported in the figure.

Before giving the details of the distributed experimental set-up let us introduce how such a problem is usually treated in a centralized way, i.e., by casting it into a $s$–$t$ minimum cut problem.

3.1 $s$–$t$ minimum cut problem

Assume the entire $D\times D$ image be available for segmentation, and denote as $V=\{1,\ldots,D^{2}\}$ the set of pixels. As shown, e.g., in [28, 29] this problem can be reduced to an equivalent $s$–$t$ minimum cut problem, which can be approached by submodular minimization techniques.

More in detail, this approach is based on the construction of a weighted digraph $G_{s-t}=(V_{s-t},E_{s-t},A_{s-t})$, where $V_{s-t}=\{1,\ldots,D^{2},s,t\}$ is the set of nodes, $E_{s-t}\subseteq V_{s-t}\times V_{s-t}$ is the edge set and $A_{s-t}$ is a positive weighted adjacency matrix. There are two sets of directed edges $(s,p)$ and $(p,t)$, with positive weights $a_{s,p}$ and $a_{p,t}$ respectively, for all $p\in V$. Moreover, there is an undirected edge $(p,q)$ between any two neighboring pixels with weight $a_{p,q}$. The weights $a_{s,p}$ and $a_{p,t}$ represent individual penalties for assigning pixel $p$ to the object and to the background respectively. On the other hand, given two pixels $p$ and $q$, the weight $a_{p,q}$ can be interpreted as a penalty for a discontinuity between their intensities.

In order to quantify the weights defined above, let us denote by $I_{p}\in[0,1]$ the intensity of pixel $p$. Then, see, e.g., [29], $a_{p,q}$ is computed as

[TABLE]

where $\sigma$ is a constant modeling, e.g., the variance of the camera noise. Moreover, weights $a_{s,p}$ and $a_{p,t}$ are respectively computed as

[TABLE]

where $\lambda>0$ is a constant and $\text{P}(x_{p}=1)$ (respectively $\text{P}(x_{p}=0)$) denotes the probability of pixel $p$ to belong to the foreground (respectively background).

The goal of the $s$–$t$ minimum cut problem is to find a subset $X\subseteq V$ of pixels such that the sum of the weights of the edges from $X\cup\{s\}$ to $\{t\}\cup V\setminus X$ is minimized.

3.2 Distributed set-up

In the considered distributed set-up, $N=8$ agents are connected according to a strongly-connected Erdős-Rényi random digraph and each of them has access only to a portion of the image (see Figure 2). In this set-up, clearly, each agent can assign weights only to some edges in $E_{s-t}$ so that, it cannot segment the entire image on its own.

Let $V_{i}\subseteq V$ be the set of pixels seen by agent $i$. Each node $i$ assigns a local intensity $I^{i}_{p}$ to each pixel $p\in V_{i}$. Then, it computes its local weights as

[TABLE]

Given the above locally defined weights, each agent $i$ construct its private submodular function $F_{i}$ as

[TABLE]

Here, the first term takes into account the edges from $X$ to $V\setminus X$, the second one those from $s$ to $V\setminus X$, and the third one those from $X$ to $t$. The last term is a normalization term guaranteeing $F_{i}(\emptyset)=0$. Then, by plugging (12) in problem (1), the optimization problem that the agents have to cooperatively solve in order to segment the image is

[TABLE]

We applied the MICKY distributed algorithm to this set-up and we split the optimization variable in $40$ blocks. In order to mimic possible errors in the construction of the local weights, we added some random noise to the image. We implemented the MICKY algorithm by using the Python package DISROPT [30] and we ran it for $K=1000$ iterations. A graphical representation of the results is reported in Figure 3. Each row is associated to one network agent while each column is associated to a different time stamp. More in detail, we show the initial condition at time $k=0$ and the candidate (continuous) solution at $k\in\{100,200,300,400,500,600\}$ iterations. The last column represents the solution $X_{i}^{\text{end}}$ of each agent obtained by thresholding $x_{i}^{k}$ with $k=1000$ and $\tau=0.5$. As appearing in Figure 3, the local solution set estimates $X_{i}^{\text{end}}$ are almost identical. Moreover, the connectivity structure of the network clearly affects the evolution of the local estimates. Finally, the evolution of the cost error is depicted in Figure 4, where $X_{i}^{k}\triangleq\{i\mid x_{i}^{k}>\tau\}$.

4 Conclusions

In this paper we presented MICKY, a distributed algorithm for solving submodular problems involving the minimization of the sum of many submodular functions without any central unit. It involves random block updates and communications, thus requiring a reduced local computational load and allowing its deployment on networks with low communication bandwidth (since it requires a small amount of information to be transmitted at each iteration). Its convergence in expected value has been shown under mild assumptions. The MICKY algorithm has ben tested on a cooperative image segmentation problem in which each agent has access to only a portion of the entire image.