A local cost simulation-based algorithm to solve distributed constraint optimization problems

Distributed constraint optimization problems

A DCOP can be defined as a tuple (A, X, D, F) (Chen et al., 2020) where.

• A = {a₁, …, a_n} is a set of agents.

• X = {x₁, …, x_m} is a set of variables, where each variable is assigned to an agent.

• D = {D₁, …, D_m} is a set of finite variable domains, where the values of the variables are taken from finite domains D₁, …, D_m.

• F = {f₁, …, f_q} is a set of constraints, where each constraint f_i:D_i1 × … × D_ik → ℝ_≥0 specifies a non-negative cost for every possible value combination of a set of variables.

For ease of understanding and discussion, we assume that one agent controls only one variable and all constraints are binary. Therefore, in this article, agent and variable can be considered as the same concept and can be replaced with each other. Figure 1 shows a simple DCOP example.

The solution objective of DCOP is to find an assignment X^∗ that minimizes the sum of constraint costs arising between all agents. (1)${\displaystyle {\mathrm{X}}^{\ast }=\underset{{\mathrm{d}}_{\mathrm{i}}\in {\mathrm{D}}_{\mathrm{i}},{\mathrm{d}}_{\mathrm{j}}\in {\mathrm{D}}_{\mathrm{j}}}{\text{argmin}}\sum _{{\mathrm{f}}_{\mathrm{ij}}\in \mathrm{F}}{\mathrm{f}}_{\mathrm{ij}}\left({\mathrm{x}}_{\mathrm{i}}={\mathrm{d}}_{\mathrm{i}},{\mathrm{x}}_{\mathrm{j}}={\mathrm{d}}_{\mathrm{j}}\right).}$

Local search framework for DCOPs

The local search algorithms are typical incomplete algorithms for solving DCOP problems. In each round, an agent sends the message that includes value or other information to neighbors in the constraint graph and receives the messages from neighbors. Then, the agent will select a new value in terms of the messages and decide whether to replace the old one according to different replacement strategies. There are different ways to create messages in different algorithms. In DSA, when the value of neighbors changes, the agent searches its domain to find a value that can reduce local cost, and replaces the old value using the new one with a probability. But in MGM, only the agent with maximal gain among all its neighbors can replace old value. In this article, DSA is used to illustrate this framework.

Table 1 presents the sketch of DSA. Firstly, the agent initializes a value randomly and sends it to all neighbors (line 1–2). Then, the algorithm executes a repeated iterative loop (line 3–9) until the termination condition is met. During the loop, an agent collects the values received from neighbors and selects a new value that reduces the local cost most (line 4–5). Finally, the agent decides to assign the new or the old value according to a probability p (line 7–9). If (Δ ≥ 0andp ≤ random()), assign the new value. Else, assign the old value.

Related work

Most of incomplete algorithms for DCOPs are context-free (Deng et al., 2021). The local search algorithms (Chapman et al., 2011) is defined as: at each iteration, agents communicate only the states of the variables under their control to their neighbours on the constraint graph, and that reason about their next state based on the messages received from their neighbours.

In the most typical local search algorithm DSA, an agent sends its value to its neighbors, and at the same time receives the value sent from neighbors. Then, according to the received value, each agent chooses a value from its variable domain that can minimize the local cost to replace the old one with probability. If the the old value is replaced, the agent will resend it to its neighbors. In another typical algorithm, MGM, all agents need to send additional gain messages to their neighbors. Then through the message passing mechanism, only the agent with the largest gain among all neighbors can replace the old value. GDBA extends the DBA algorithm to the general DCOP problem and spans 24 combinations of three design choices. The three designs are strategies to modify the basic cost using multiple weights or additional penalties, definitions of constraint violations such as non-zero cost, non-minimal cost and maximum cost, and modifying the scope of the cost table like entries, rows, columns, or tables during breakthrough. DSAN is an improved version of DSA by applying simulated annealing to make DSA jump out of the local optimum.

The LCS proposed in this article mainly utilizes the historical information that current local search algorithms ignore. The exponential weighted moving average method is used to maintain and update the local cost simulation value, and the population cooperation mechanism is used to fully search the local cost simulation value, thereby improving the quality of the solution.

Motivation

In local search algorithms, only two successive rounds of information are taken into account and the historical information from previous rounds is wasted. For the DSA, the current value depends on the local cost difference between the current round and the previous round. That is, the value only depends on changes in a single round of neighbors’ values. The local cost is non-increasing in this strategy, and it is easy to fall into a local optimum. MGM follows the main idea of DSA, although the interactive competition between neighbors has been added to determine the value changes. For DSAN (Arshad & Silaghi, 2004), only the idea of Simulate Anneal Arithmetic (SAA) is introduced to control the search process to disturb the assignment probability when the algorithm falls into the local optima. The same is true for PDS, LSGA, etc. All of them make no use of the series of changes in local cost and its historical records of values.

In fact, for the local search algorithms, the purpose of the agent to change values is generally to reduce the local cost. At the time of local cost decreases, global cost always performs a downward trend as rounds increase. Various improved local search algorithms all focus on the conflict between local cost and global cost because when the global cost decreases while the local costs of some agents increase.

These improvement strategies are committed to making algorithms break away from the monotonic decline of local cost to jump out of the local optima and search for higher-quality solutions. All of these improved algorithms have not taken into account the change records of the local cost. The sum of the local costs of all agents is equal to the global cost of the system. It can be seen that the change of global cost is closely related to that change of the local cost. Suppose that the estimated local cost of each value is known, we can select the lower one to get a lower global cost. There are different local costs and different changes for different values. Thus, it is necessary to estimate the local cost for each value in the domain according to the historical value of agents to guide their assignments. Based on this, we propose a novel algorithm named LCS to solve DCOP based on the idea of local cost simulation.

LCS

LCS consists of two phases: initialization and local cost simulation. We modify the existing ALS framework to make it compatible with the population of LCS. The sketch of LCS can be found in Table 2. Each value in the agent value range has a local cost simulation value that needs to be maintained, and the simulation value is the simulation value of the historical local cost generated when the value in the value range is selected. When the value of a_i is d_i, the local cost simulation value of d_i is denoted as $\mathrm{est}\left({\mathrm{d}}_{\mathrm{i}}\right)$.

Table 2:

The sketch of LCS.

DOI: 10.7717/peerjcs.1296/table-2

Definition 1: An individual is a value with a serial number. Individuals with the same serial number in all agents represent a solution. A population is a collection of individuals with its own unique local cost simulation.

Definition 2: $\mathrm{es}{\mathrm{t}}_{{\mathrm{c}}_{\mathrm{k}}}{\left({\mathrm{d}}_{\mathrm{i}}\right)}^{\mathrm{r}}$ is the simulation (or estimation) of the local cost that d_i ∈ D_i will produce. Where c_k ∈ C is the serial number of the population, and r is the number of simulation updates.

Initialization initiates the simulation and assigns values to individuals. Suppose that there are C populations, each of which has P individuals (C and P are the hyper-parameters). Since the algorithm has not yet started, we create the same initial simulation for all populations. For agent a_i, the initial simulations (estimations) can be calculated by: (2)${\displaystyle \mathrm{es}{\mathrm{t}}_{{\mathrm{c}}_{\mathrm{k}}}^0\left({\mathrm{d}}_{\mathrm{i}}\right)=\sum _{\mathrm{m}\in {\mathrm{N}}_{\mathrm{i}}}\underset{{\mathrm{d}}_{\mathrm{j}}\in {\mathrm{D}}_{\mathrm{m}}}{max}\text{cost}\left({\mathrm{d}}_{\mathrm{i}},{\mathrm{d}}_{\mathrm{j}}\right)}$ where ${\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^0\left({\mathrm{d}}_{\mathrm{i}}\right)$ is the initial estimation for c_k ∈ C. The estimation can simulate previous local costs and be updated according to the change of the local cost. It reflects the quality of d_i and records the change of neighbors’ values. Here it represents the worst case for d_i. And N_i is the neighbor of a_i, cost(d_i, d_j) isthe constraint cost generated when a_i takes the value of d_i, and its neighbor a_j takes the value of d_j.

Taking Fig. 1 for an example, we assume that there are two populations, with two individuals in each population respectively. The estimations for x₁ should be calculated by: ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_1}^0\left(1\right)={\mathrm{est}}_{{\mathrm{c}}_2}^0\left(1\right)=4+3+5=12}$ ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_1}^0\left(2\right)={\mathrm{est}}_{{\mathrm{c}}_2}^0\left(2\right)=5+5+4=14}$

After the estimations are initialized, each agent executes the StartCycle to start message-passing. The agent constructs populations and individuals to save values per round. We use V _i to represent the value set of populations for a_i. At the first round, individual p ∈ P of population c_k ∈ C selects an initial value V _ck,p in the domain for itself randomly. After the selection of all individuals, the agent sends the set V _i with values to all neighbors.

For example in Table 3, after initialization, the individuals in each agent are randomly assigned.

Local cost simulation is a procedure to search for solutions. In this phase, the agent communicates continuously with its neighbors, calculates the local cost to update the simulated value, conducts population interaction to better simulate the local cost, and conducts a sufficient search for the potential of the value.

After the agent receives the sets V _m of neighbors, LCS needs to update simulations by local cost. The local cost for each individual can be calculated by: (3)${\displaystyle {\mathrm{loc}}_{{\mathrm{c}}_{\mathrm{k}},\mathrm{p}}=\sum _{\mathrm{m}\in {\mathrm{N}}_{\mathrm{i}}}{\text{cost}}_{\mathrm{i},\mathrm{j}}\left({\mathrm{V}}_{{\mathrm{c}}_{\mathrm{k}},\mathrm{p},\mathrm{i}},{\mathrm{V}}_{{\mathrm{c}}_{\mathrm{k}},\mathrm{p},\mathrm{m}}\right)}$ where loc_ck,p is the local cost which is calculated by individual p of population c_k and the same individuals of neighbors.

Continuing the example above, local costs for x₁ can be calculated using: ${\displaystyle {\mathrm{loc}}_{{\mathrm{c}}_1,{\mathrm{p}}_1}=3+3+2=8,{\mathrm{loc}}_{{\mathrm{c}}_1,{\mathrm{p}}_2}=4+3+5=12}$ ${\displaystyle {\mathrm{loc}}_{{\mathrm{c}}_2,{\mathrm{p}}_1}=3+1+5=9,{\mathrm{loc}}_{{\mathrm{c}}_2,{\mathrm{p}}_2}=2+4+4=10.}$

When the local cost of each individual has been obtained, the agent needs to update the estimation to simulate its change. Considering the temporal relationship between local cost and round, we use the EWMA to simulate the local cost. The updating method of estimation is defined as: (4)${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{r}}\left({\mathrm{d}}_{\mathrm{i}}\right)={\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{r}-1}\left({\mathrm{d}}_{\mathrm{i}}\right)\ast {\beta }_{{\mathrm{c}}_{\mathrm{k}}}+{\mathrm{loc}}_{{\mathrm{c}}_{\mathrm{k}},\mathrm{p}}\ast \left(1-{\beta }_{{\mathrm{c}}_{\mathrm{k}}}\right)}$ where β_ck is the decay rate of population c_k, and r is the number of updates.

Here, we assume that ${\beta }_{{\mathrm{c}}_1}=0.5,{\beta }_{{\mathrm{c}}_2}=0.6.{\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^0$can be found at formulation 1. The estimations for x₁ can be calculated as: ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_1}^1\left(1\right)=12\ast 0.5+8\ast 0.5=10}$ ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_1}^2\left(1\right)=10\ast 0.5+12\ast 0.5=11}$ ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_2}^1\left(1\right)=12\ast 0.6+9\ast 0.4=10.8}$ ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_2}^1\left(2\right)=14\ast 0.6+10\ast 0.4=12.4}$

After the update, the simulations of x₁ become: ${\mathrm{est}}_{{\mathrm{c}}_1}\left(1\right)={\mathrm{est}}_{{\mathrm{c}}_1}^2\left(1\right)=11,{\mathrm{est}}_{{\mathrm{c}}_1}\left(2\right)={\mathrm{est}}_{{\mathrm{c}}_1}^0\left(2\right)=14,{\mathrm{est}}_{{\mathrm{c}}_2}\left(1\right)={\mathrm{est}}_{{\mathrm{c}}_2}^1\left(1\right)=10.8,{\mathrm{est}}_{{\mathrm{c}}_2}\left(2\right)={\mathrm{est}}_{{\mathrm{c}}_2}^1\left(2\right)=12.4$. If there is no superscript on est_ck(d_i), it means est_ck(d_i) is the current latest value.

After each population has updated its simulated values, a new estimate of the local cost that is closer to the actual local cost is obtained. At this time, in order to give full play to the advantages of the population, LCS sets up an exchange round, allowing the populations to share the simulated values they have found, which can tell those populations with poor simulated values that they have better values and better directions. to explore. The LCS pre-sets the exchange interval rounds, and every ecy rounds, the agent will exchange the obtained analog values. The purpose of the exchange operation is to share different search directions between populations. The exchange is defined as: (5)${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}\left({\mathrm{d}}_{\mathrm{i}}\right)={\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}\left({\mathrm{d}}_{\mathrm{i}}\right)\ast \left(1-\gamma \right)+\underset{\mathrm{c}\in \mathrm{C}}{min}{\mathrm{est}}_{\mathrm{c}}\left({\mathrm{d}}_{\mathrm{i}}\right)\ast \gamma }$ where γ is the learning rate. It can affect the reduction of estimation, by which the population can evolve to the best one.

Since just update, ${min}_{\mathrm{c}\in \mathrm{C}}{\mathrm{est}}_{\mathrm{c}}\left(1\right)={\mathrm{est}}_{{\mathrm{c}}_2}^1\left(1\right)=10.8,{min}_{\mathrm{c}\in \mathrm{C}}{\mathrm{est}}_{\mathrm{c}}\left(2\right)={\mathrm{est}}_{{\mathrm{c}}_2}^1\left(2\right)=12.4$. We assume if γ = 0.5, the exchange values for x₁ can be calculated by: ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_1}\left(1\right)=11\ast 0.5+10.8\ast 0.5=10.9}$ ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_1}\left(2\right)=14\ast 0.5+12.4\ast 0.5=13.2}$ ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_2}\left(1\right)=10.8\ast 0.5+10.8\ast 0.5=10.8}$ ${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_2}\left(2\right)=12.4\ast 0.5+12.4\ast 0.5=12.4}$

After being updated and exchanged, each individual executes a new round to select values. The agent needs to calculate the probability for each population since the estimations in populations are different. Reciprocal of estimation is used to get the probability. The probability for selecting value d_i is defined as: (6)${\displaystyle {\mathrm{prb}}_{{\mathrm{c}}_{\mathrm{k}}}\left({\mathrm{d}}_{\mathrm{i}}\right)=\frac{{\left(1/{\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}\left({\mathrm{d}}_{\mathrm{i}}\right)\right)}^{\alpha }}{\sum _{{\mathrm{d}}_{\mathrm{i}}^{{}^{\prime }}\in {\mathrm{D}}_{\mathrm{i}}}{\left(1/{\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}\left({\mathrm{d}}_{\mathrm{i}}^{{}^{\prime }}\right)\right)}^{\alpha }}}$ where α is a parameter that significantly affects the quality of the solution by enhancing the selected probability of d_i. Because the range of estimation for different problems is distinct, it is necessary to set different α. Assume α = 8 here, the probability for c₁ of x₁ can be calculated by: ${\displaystyle {\mathrm{prb}}_{{\mathrm{c}}_1}\left(1\right)=\frac{{\left(1/10.9\right)}^8}{{\left(1/10.9\right)}^8+{\left(1/13.2\right)}^8}=0.822}$ ${\displaystyle {\mathrm{prb}}_{{\mathrm{c}}_1}\left(2\right)=\frac{{\left(1/13.2\right)}^8}{{\left(1/10.9\right)}^8+{\left(1/13.2\right)}^8}=0.178.}$

After finishing the new V _ck,p selection, the agent sends the new V _ito neighbors again. At this time, one round is completed and the agent repeats the local cost simulation until all rounds are over. Because of the ALS, the optimal solution is x₁ = 1, x₂ = 2, x₃ = 2, x₄ = 1, which gets the lowest cost 8 in this round.

Theory

In this section, we prove the feasibility of EWMA, the availability of solution quality improvement, and the superiority of population interaction.

Lemma 1. EWMA will approach the actual local cost as the rounds go infinity.

Proof. Exponential weighted moving average means that the weighted coefficient of value decreases exponentially as time and can simulate the average value of a time series. The closer value is to the current moment, the greater the weighted coefficient is. In LCS, with the increasing of rounds the influence of previous local costs decreases, the average value obtained by EWMA can put less attention on it and focuses on the local costs in recent rounds. EWMA can alter the decay rate β to emphasize different rounds, the expression is: (7)${\displaystyle {\mathrm{v}}_{\mathrm{t}}=\beta \ast {\mathrm{v}}_{\mathrm{t}-1}+\left(1-\beta \right)\ast {\theta }_{\mathrm{t}}}$ when v₀ = 0, there are: (8)${\displaystyle {\mathrm{v}}_{\mathrm{t}}=\left(1-\beta \right)\left({\theta }_{\mathrm{t}}+\beta {\theta }_{\mathrm{t}-1}+{\beta }^2{\theta }_{\mathrm{t}-2}+\cdots +{\beta }^{\mathrm{t}-1}{\theta }_1\right).}$

From formula (8), θ corresponds to the local cost, the weighting coefficient corresponding to θ₁ is β^t−1. When t is large, the coefficient value is close to 0 and decreases exponentially. The weighting coefficient corresponding to θ_t is 1, and the weight ratio is relatively large. There are multiple populations in the LCS, and different β can be set for the population. Both focus on different stages and control the diversity of searches.

Proposition 1. The quality of solutions improves as the number of message rounds increases before convergence.

Proof.What is the idea of LCS? The relationship between global cost and local cost is: (9)${\displaystyle \mathrm{glc}=\frac{1}{2}\sum _{{\mathrm{a}}_{\mathrm{i}}\in \text{Agent}}\mathrm{lo}{\mathrm{c}}_{{\mathrm{a}}_{\mathrm{i}}}}$ where glc is the global cost, loc_ai is the local cost of agent a_i. The function of LCS is to approach loc_ai: (10)${\displaystyle \underset{\mathrm{r}\to \mathrm{\infty }}{lim}\mathrm{es}{\mathrm{t}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{r}}\left({\mathrm{d}}_{\mathrm{i}}\right)=\mathrm{loc}\left({\mathrm{d}}_{\mathrm{i}}\right)}$

We assume that the algorithm converges at the zth round. According to the converse method, we assume that the quality of the algorithm solution decreases as the number of iteration rounds increases. Then the quality of the algorithm solution at round u is less than round u − x, x is the number of rounds in which the algorithm falls into local optimum. To simplify the proof, we assume that x = 1. (1 < x < u < z) (11)${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{u}}\left({\mathrm{d}}_{\mathrm{i}}\right)-{\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{u}-1}\left({\mathrm{d}}_{\mathrm{i}}\right)<0}$ (12)${\displaystyle {\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{u}-1}\left({\mathrm{d}}_{\mathrm{i}}\right)\ast {\beta }_{{\mathrm{c}}_{\mathrm{k}}}+{\mathrm{loc}}_{{\mathrm{c}}_{\mathrm{k}},\mathrm{p}}\ast \left(1-{\beta }_{{\mathrm{c}}_{\mathrm{k}}}\right)-{\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{u}-1}\left({\mathrm{d}}_{\mathrm{i}}\right)<0}$ (13)${\displaystyle {\mathrm{loc}}_{{\mathrm{c}}_{\mathrm{k}},\mathrm{p}}\ast \left(1-{\beta }_{{\mathrm{c}}_{\mathrm{k}}}\right)-{\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{u}-1}\left({\mathrm{d}}_{\mathrm{i}}\right)\ast \left(1-{\beta }_{{\mathrm{c}}_{\mathrm{k}}}\right)<0}$ (14)${\displaystyle \left({\mathrm{loc}}_{{\mathrm{c}}_{\mathrm{k}},\mathrm{p}}-{\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{u}-1}\left({\mathrm{d}}_{\mathrm{i}}\right)\right)\ast \left(1-{\beta }_{{\mathrm{c}}_{\mathrm{k}}}\right)>0}$ where ${\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{u}}$ is is the simulated value of the local cost of the uth round, loc_ck,p is the local cost of the corresponding round.

Formula (11) is the inequality obtained from the assumption. Bring formula (4) to get formula (12). Merge similar terms to formula (13) and according to formula (10), the value of loc_ck,p is greater than ${\mathrm{est}}_{{\mathrm{c}}_{\mathrm{k}}}^{\mathrm{u}-1}$, then the assumption does not hold. Therefore, the quality of solutions improves as the number of message rounds increases before convergence.

Complexity

In this section, we analyze the complexity of LCS. We define the number of agents |A| = n, the number of neighbors of agent x_i is |N|.

In the initialization and local cost simulation, only population messages need to be sent per round, so the size of the message is O(|C|∗|P|), where |C| is the number of populations and |P| is the number of individuals per population.

The time complexity of LCS mainly depends on the update of simulations and the calculation of value messages. When updating the simulations, it is necessary to calculate the local cost for each individual. When calculating local cost, one individual requires O(|N|) complexity. So, complexity for all populations requires O(|C|∗|P|∗|N|). For the calculation of the value message, the agent just needs to traverse the simulations to calculate the probability. The calculation of probability and selection of value can be done sequentially. So, the time complexity of the calculation of the value message is O(|C|∗max(|P|, |M|)), where |M| is the length of the domain. In summary, the time complexity of LCS is O(n).

Benchmark problems

We empirically evaluate our proposed method with peer algorithms including DSA (type-C and p = 0.6), MGM, GDBA, PDS, ACO_DCOP ( K = 19), Max-sum_ADVP, Damped Max-sum and LSGA. DSA, MGM and GDBA are implemented under the ALS framework. For PDS and LSGA, we choose PDS-DSA and LSGA-DSA (M = 18) who perform the best. And LCS is run on ALS framework to record the optimal solution during the iterations.

Our extensive empirical evaluations are benchmarked on four types of problems including random DCOPs, scale-free networks (SFN), weighted graph coloring problems (WGC) and random meeting scheduling problems (Chen et al., 2020). The recommended values of α are shown in Table 4. For random DCOPs, we set the agent number to 70 and 120, domain size to 10, choose the constraint uniformly from [1,100], and consider the graph density 0.1 (for sparse) or 0.6 (for dense). For SFN, we set the agent number to 150, domain size to 10, choose the constraint uniformly from [1,100], and consider the problems with m₁ = 20, m₂ = 3 (for sparse) and m₁ = 20, m₂ = 10 (for dense). For WGC, we set the agent number to 120, the available color number to 3, constraint density to 0.05, and choose the constraint uniformly from [1,100]. For random meeting scheduling problems, we set the agent number to 90, the meeting number to 20, the available time-slots to 20, and travel times are randomly selected from 6 to 10. The experimental results take the average of 50 independent problems that each execute 30 times. We run our experiments on a laptop with an Intel Core i7-6700 CPU 2.60 GHz and 8 GB RAM.

Memory footprints & network load

In terms of memory footprints, we set different population sizes to test on random DCOPs and scale-free networks. We take the maximum value of memory footprints for multiple runs of the algorithm. Table 5 shows that population sizes, density and the agent number are all proportional to memory footprints. In terms of network load (Nguyen et al., 2019), that is, the amount of information passed around the network, LCS send a polynomial amount of information in each iteration.

Influence of population size

In order to discuss the influence of population size on the performance of the LCS, we ensure that the parameters α, β, γ of LCS are constant and use many different combinations of population sizes of C = 1, 2, 3, 4, 5, P = 8, 16, 24, 30. We choose sparse random graphs of 70 agents and the obtained results are shown in Table 6. From the analysis of the results, the higher the number of populations C and the number of individuals P is set, the higher the solution quality of the algorithm is, and the running time of the algorithm increases. However, after the solution quality decreases to a certain level, continuing to increase C and P only results in a small gain. At this point, the increasing trend of the algorithm running time becomes larger and the gain ratio obtained is not high. Therefore, according to the results of the table, C = 4, P = 24 is chosen to weigh the solution quality and running time.

Influence of population learning rate

In order to discuss the influence of population learning rate on the performance of the LCS, we set different population learning rate γ and the obtained results are shown in Table 7. We still choose sparse random graphs of 70 agents and γ = 0, 0.1, 0.3, 0.5, 0.7, 0.9. And to make the population emphasize different phases, β = 0.9, 0.8, 0.7, 0.6 are selected, but you can also try other values. By analyzing the experimental results, when γ = 0, no value exchange between populations was performed at this time. Comparison with the cost of the algorithm after the introduction of the population learning rate γ shows poor results. The effectiveness of the algorithm was improved after the introduction of γ, which confirmed the effectiveness of population cooperation. According to the result, γ = 0.7 performs the best solution.

Influence of population cooperation mechanism

In this section, we evaluate the influence of the population cooperation mechanism. We call the LCS without population cooperation mechanism as LCS-WPCM. We set the same parameter for both algorithms as $\mathrm{C}=4,\mathrm{P}=24,\beta =\left\{0.9,0.8,0.7,0.6\right\}$ and γ = 0.7.

Figures 2 and 3 show the convergence curve of LCS-WPCM and LCS on sparse and dense random graphs with 70 agents. From Figs. 2 and 3, we can see that whether in sparse graph or dense graph, population cooperation mechanism can improve the convergence quality of LCS.

Comparisons with the state-of-the-art algorithms

In this section, LCS was compared with the comparison algorithm on the four Benchmark problems. According to the previous analysis, we set the parameters of LCS as $\mathrm{C}=4,\mathrm{P}=24,\beta =\left\{0.9,0.8,0.7,0.6\right\}$ and γ = 0.7. The Max-sum_ADVP and the Damped Max-sum for our comparison experiments are non-anytime, so we give the experimental results separately.

Figures 4–6 show the comparison between LCS and other algorithms in random DCOPs (|A| = 70, p = 0.1; |A| = 70, p = 0.6), and Table 8 gives the comparisons of all other problems. All differences are statistically significant for p − value < 1 × 10⁻³⁶. Compared to the other algorithms, LCS improves the solution quality on sparse problems by 2.2% ∼ 21.8% and on dense problems by 0.7% ∼ 5.7%. By analyzing the decline curve of LCS, it can be found that some more twists and turns are caused by multiple search phases and population interaction. In the initial phase of iteration, LCS decreases more slowly than LSGA-DSA or ACO_DCOP because estimations have not been simulated well. But after a full search, LCS performs better than all other algorithms and cost shows a slow downward trend all the time. LCS has good search ability for both sparse and dense problems, while the other algorithms are biased to only one of them and cannot catch up with the LCS algorithm.

Figures 7–9 show the comparison between LCS and other algorithms in random DCOPs (|A| = 120, p = 0.1; |A| = 120, p = 0.6). Compared to the other algorithms, LCS improves the solution quality on sparse problems by 1.5% ∼ 19.3% and on dense problems by 0.4% ∼ 4.0%. Population-based LSGA-DSA and LCS with population achieved better results than other algorithms, but LSGA-DSA results were not as good as LCS, which proves that the local cost of simulation in DCOP is better than genetic algorithm coding. Since the global cost increases with the number of agents and the problem size, the degree of improvement of LCS is lower than before. However, the LCS algorithm still has higher solution quality than other algorithms for sparse and dense problems due to the local cost simulation method and population cooperation with each other.

Figures 10– 12 show the comparison between LCS and other algorithms in scale-free networks( |A| = 150, m1 = 20, m2 = 3; |A| = 150, m1 = 20, m2 =10). From the experimental results it can be seen that the algorithm runs longer on this problem because of its larger size. Compared to the other algorithms, LCS improves the solution quality on sparse problems by 2.1% ∼ 26.6% and on dense problems by 1.0% ∼ 9.8%. The improvement effect shows that the algorithm improves less on the dense problem than on the sparse problem. The reason for this is that as the number of neighbors connected to the centroids in the scale-free network increases, the simulation accuracy of the local cost is affected and its fluctuation range becomes larger. However, the algorithm preserves the probability of being selected for all values in the value domain, so the effect of this error is improved, which makes the LCS still outperform the other algorithms. Table 8 shows that LCS has good search capability for both sparse and dense problems in different problems, where other algorithms can not catch up with the effect of LCS.

Figures 13 and 14 presents the comparison of LCS with other algorithms on weighted graph coloring problems (|A| = 120, p = 0.05). Compared to the other algorithms, LCS improves by 38.4% ∼ 85.3%, which is a great improvement. In this problem, it can be found that all algorithms solve with a lower value of global cost, and the solution of PDS-DSA algorithm has dropped to more than 300, which is already a better solution. However, in contrast to it, LCS drops the solution to about 200, which greatly improves the solution quality. The weighted graph coloring problem favors DCSP (Yokoo et al., 1998) similarly, which proves that LCS may be superior in solving similar problems such as DCSP.

Figure 15 presents the comparison of LCS with other algorithms on random meeting scheduling problems(|A| = 90). We omit the results of MGM and GDBA due to their inferior performances (Chen et al., 2020). Compared to the other algorithms, LCS improves by 0.6% ∼ 4.2%. In this problem, it can be found that all algorithms solve with a lower value of global cost. Experimental results show that LCS outperforms other algorithms and can improve real-world problems.