Distributed constraint optimization algorithm and system based on subgradient re-scaling

Abstract

The invention relates to a distributed constraint optimization algorithm and system based on subgradient rescaling, and belongs to the technical field of information communication. According to the algorithm, for the distributed constraint optimization problem of the time-varying directed network, a time-varying directed graph meeting consistent joint strong connectivity and column randomness is constructed; initializing node variables; in each iteration, nodes transmit and receive variables and update the variables, and the variables and state variables are updated through a Polyak random projection technology; and repeatedly iterating to a stop rule, and outputting an optimal variable. The problem of imbalance of the time-varying directed network and the problem of complex constraint processing are solved, the calculation load is reduced, the problem of secondary optimization is avoided, the optimization efficiency is higher, and the application range is wider.

Description

Technical Field

[0001] This invention belongs to the field of information and communication technology, and relates to a distributed constraint optimization algorithm and system based on subgradient rescaling. Background Technology

[0002] With the rapid development of large-scale networks, the demand for optimization problems in fields such as data analysis, wireless sensor networks, and information security is increasing. Traditional centralized algorithms are gradually revealing their limitations when handling complex computational tasks. These algorithms typically require all data to be processed in a central location, which not only increases the computational burden but may also lead to network congestion and latency issues. Compared to centralized algorithms, distributed algorithms can decompose complex computational tasks into multiple subtasks and process them in parallel on various nodes in the network. This approach not only improves the ability to process large-scale data but also enhances the scalability and robustness of the system, attracting increasing attention.

[0003] In recent years, to effectively solve optimization problems, researchers have developed various distributed algorithms, such as distributed subgradient methods, distributed double averaging methods, and distributed augmented Lagrangian methods, to achieve consensus among nodes through specially designed communication protocols. In practical applications, information is often transmitted unidirectionally, and some methods become inapplicable when the communication network structure is unbalanced. To address these issues, researchers have designed a series of algorithms for unbalanced networks, such as subgradient descent algorithms based on push-pull gradients and surplus. Furthermore, algorithms based on subgradient rescaling strategies have been widely applied to solve the problem of imbalanced information transmission in time-varying directed networks.

[0004] In addition, existing algorithms typically consider unconstrained optimization problems or those with global / local set constraints, which may not be suitable for optimization problems with more complex constraints (multiple sets and inequality or equality constraints). These problems place higher demands on algorithm design and implementation. For optimization problems with more complex constraints on directed networks, researchers have developed several effective algorithms, such as the distributed Polyak stochastic fixed projection algorithm. This algorithm solves optimization problems with multiple local inequality constraints on time-varying directed networks and addresses imbalance problems through the mirror image of the objective function. However, the need to solve an additional inequality constraint increases the algorithm's complexity and computational cost. Furthermore, distributed constraint optimization algorithms based on the AB / push-pull framework can adapt to time-varying directed networks, but require each node to store all gradient information from the previous time step, making them unsuitable for large-scale optimization problems in resource-constrained networks.

[0005] Therefore, to address the two problems mentioned above, this invention proposes a distributed constraint optimization algorithm and system based on subgradient rescaling and distributed Polyak random projection techniques. Summary of the Invention

[0006] In view of this, the purpose of this invention is to provide a Subgradient-Rescaling-Based Decentralized Fixed-Random Projection (SR-DFRP) algorithm and system. This algorithm and system are based on subgradient rescaling and distributed Polyak random projection techniques. Subgradient rescaling addresses the imbalance problem caused by time-varying directed networks, while distributed Polyak random projection handles non-identical and multiple constraint sets, reducing computational load and avoiding suboptimal problems. Compared to existing algorithms, this invention's algorithm has higher optimization efficiency and a wider range of applicability.

[0007] To achieve the above objectives, the present invention provides the following technical solution:

[0008] A distributed constraint optimization algorithm based on subgradient rescaling is proposed. This algorithm targets distributed optimization objectives with non-identical constraint sets and multiple constraint sets in time-varying directed networks. Based on subgradient rescaling and Polyak random projection techniques, it solves the complex optimization problem of non-equilibrium networks, including the following steps:

[0009] S1: For the distributed constraint optimization problem in time-varying directed networks, a time-varying directed graph is constructed based on the network topology. The time-varying directed graph satisfies consistent joint strong connectivity, and the corresponding generated weight matrix satisfies column randomness.

[0010] S2: Initialize all node variables, including state variables and auxiliary variables;

[0011] S3: In each iteration, perform the following operations: The node sends auxiliary variables and state variables to its outgoing neighbors; the node receives auxiliary variables and state variables from its incoming neighbors and updates the auxiliary variables and intermediate state variables based on the subgradient rescaling technique; the node updates the substate variables based on the updated auxiliary variables and intermediate state variables by using Polyak fixed projection and Polyak random projection techniques; then the substate variables are projected onto random components of the locally compact convex constraint set to update the state variables.

[0012] S4: Repeat step S3 until the preset stopping rule is met, and output the globally optimal state variable.

[0013] Optionally, the distributed optimization problem is:

[0014]

[0015] in It is a non-empty closed convex set; each node i privately knows its local convex objective function f. i : and locally compact convex constraint sets Locally compact convex constraint set Λ i Describe the intersection of a finite number of convex sets, i.e. Among them O i It is the set of indices of node i; τ i >0 is a constant representing a convex function vector known only to node i, where g i,l : l∈{1,…,τ i} is g i A component of (x); It is a matrix and a vector with full row rank.

[0016] Define f * To achieve the optimal value, we introduce... and Ω0=Ω1∩…∩Ω n ,Ω * ={x∈Ω0|f(x)=f * The optimization problem satisfies the following assumption: the optimization problem has at least one finite solution x. * The feasible solution set Ω0 and the optimal solution set Ω of the optimization problem * All are nonempty and compact; locally convex objective function f i The following assumptions are satisfied:

[0017] f i The subgradient ▽f at x i (x) satisfies: f i (x)-f i (y)≤▽f i (x) T (xy);

[0018] Subgradient ▽f i (x), i = 1, ..., n, are uniformly bounded on the set Λ0, that is, for all state variables x ∈ Λ0 and nodes i = 1, ..., n, we have ||▽f i (x)‖≤D f , where the constant D f >0.

[0019] Optionally, the time-varying directed graph constructed in step S1 can be described as G k ={V,E k}, where time k≥0, and V={1,2,…,n} represents the set of nodes. Let E represent the set of edges; if node j can directly send a message to node i at time k, then edge (j,i)∈E. k Where node j is considered an incoming neighbor of node i, and correspondingly node i is an outgoing neighbor of node j; the set of incoming neighbors of node i at time k is represented as follows: The set of out neighbors of node i at time k is represented as If the in-degree of node i is not equal to its out-degree at any time k, then the time-varying directed graph G... k It is unbalanced; G k The weight matrix is ​​denoted as Where (j,i)∈E k ,but otherwise

[0020] G k The following assumptions are satisfied:

[0021] 1) There exists a positive integer B such that for any time k≥0, the joint network G k ∪G k+1 ∪...∪G k+B-1 It is strongly connected;

[0022] 2)G k Weight matrix A k It is a random sequence, for all nodes i,j∈V, time k≥0, we have

[0023] 3) There exists a scalar γ > 0 such that for any node i, j ∈ V, time k ≥ 0, if but

[0024] Optionally, initializing the variables for all nodes specifically includes:

[0025] S21: Initialize the variables of all nodes i∈V as follows: state variables Initialize to Auxiliary variables Initialize to

[0026] Optionally, step S3 includes:

[0027] S301: Set the iteration count k for all nodes i∈V to 1, and set a maximum iteration count K as the criterion for stopping the algorithm's iteration update;

[0028] S302: Transform the time-varying directed network G k Corresponding column random matrix It is used as a weight parameter in network communication and distributed to each node;

[0029] S303: Node i sends a message to its outgoing neighbor node. send and

[0030] S304: Node i's incoming neighbor node Received and Next, update the auxiliary variables. and intermediate state variables The update rules are as follows:

[0031]

[0032] in, Representation matrix The elements in the i-th row and j-th column are a row random matrix; α k It is a decreasing step size, satisfying and

[0033] S305: Intermediate state variable of node i By using the Polyak fixed projection concept to project onto the global constraint set X i,0 Projection, update to obtain variables The update rules are as follows:

[0034] if but:

[0035]

[0036] otherwise in, i∈V, It is a constant parameter;

[0037] S306: Node i uses the Polyak random projection concept to make the variable... To a randomly selected local constraint set X i,l Update, obtain sub-state variables The update rules are as follows:

[0038]

[0039] in, l∈{1,…,τ i}, It is a constant parameter. It is at time k from the set of integers {1,…,τ} iA random variable randomly selected from}, if Then vector Otherwise, for a certain vector u i ≠0

[0040] S307: Node i passes the child state variable Projected onto the locally compact convex constraint set Λ i On a randomly selected component, to obtain the updated state variable The update rules are as follows:

[0041]

[0042] in, At time k, from set O i Random variables randomly selected from the data; once all nodes reach a consensus, the state variables of each node... It will asymptotically converge to a point in the set Ω0 in the sense of the mean;

[0043] S308: Set the iteration count k to k+1. If the iteration count is less than the maximum iteration count and the state variables of all nodes have not converged to the consensus value, return to step S303 to continue executing the algorithm until the iteration count k≥K or the state variables of all nodes converge to the consensus value. The algorithm then stops running and returns the state variables of each node that have reached consensus. As the optimal solution of the objective function.

[0044] This invention also provides a location optimization method based on subgradient rescaling distributed constraints, which realizes cooperative location optimization of distributed nodes based on the optimization algorithm described in any of the above claims, including the following steps:

[0045] S1: For the distributed addressing optimization problem in time-varying directed networks, a time-varying directed graph is constructed based on the network topology to ensure that the time-varying directed graph satisfies consistent joint strong connectivity and that the corresponding generated weight matrix satisfies column randomness; the distributed addressing optimization problem aims to minimize the total construction cost, and each node corresponds to a local addressing objective function and a local compact convex constraint set, which includes at least one of location range constraints, coverage range constraints, and resource allocation constraints;

[0046] S2: Initialize the variables of all nodes, including local addressing state variables and auxiliary variables, wherein the local addressing state variables represent the candidate addressing location parameters of the nodes;

[0047] S3: Perform the following operations at each iteration:

[0048] S301: The node sends the current auxiliary variables and local addressing status variables to its outgoing neighbor node;

[0049] S302: The node receives auxiliary variables and local addressing state variables from the incoming neighbor nodes, and updates its own auxiliary variables and intermediate state variables according to the preset update rules based on the subgradient rescaling technique and the weight parameters of the row random matrix.

[0050] S303: Nodes use the Polyak fixed projection method to project intermediate state variables onto the global constraint set X. i,0 Projection, update to obtain variables The global constraint set X i,0 The intersection of all local addressing constraints for all nodes;

[0051] S304: Nodes use the Polyak random projection method to transform variables. To a randomly selected local constraint set X i,l Projection and update yield sub-state variables

[0052] S305: The node will change the child state variable Project the updated local addressing state variables onto a randomly selected component of the local addressing constraint set.

[0053] S4: Repeat step S3 until the number of iterations reaches the preset maximum number of iterations or the local addressing state variables of all nodes converge to the consensus value, and output the consensus value as the optimal addressing location parameter.

[0054] This invention also provides an image deblurring method based on subgradient rescaling distributed constraints, which implements distributed node cooperative image deblurring processing based on the optimization algorithm described in any of the preceding claims, including the following steps:

[0055] S1: For the distributed image deblurring problem in time-varying directed networks, a time-varying directed graph is constructed based on the network topology to ensure that the time-varying directed graph satisfies consistent joint strong connectivity and that the corresponding generated weight matrix satisfies column randomness; the image deblurring problem aims to minimize image degradation loss, and each node stores the local degraded image and the corresponding blur kernel, and has a private local convex objective function and a local compact convex constraint set (including pixel non-negativity constraints and known pixel value constraints);

[0056] S2: Initialize the variables of all nodes, including the state variable xk and auxiliary variables. The state variable xk represents the pixel estimate during the image deblurring process;

[0057] S3: Perform the following operations at each iteration:

[0058] S301: The node sends its current auxiliary variables and state variables to its outgoing neighbor node;

[0059] S302: The node receives auxiliary variables and state variables from the incoming neighbor nodes, and updates its own auxiliary variables and intermediate state variables according to the preset update rules based on the subgradient rescaling technique and the weight parameters of the row random matrix.

[0060] S303: Nodes use the Polyak fixed projection method to project intermediate state variables onto the global constraint set, updating the variables.

[0061] S304: Nodes use the Polyak random projection method to transform variables. Projecting onto a randomly selected set of local constraints, the sub-state variables are updated.

[0062] S305: The node will change the child state variable Projecting onto a randomly selected component of a locally compact convex constraint set, the updated state variables are obtained.

[0063] S4: Repeat step S3 until the number of iterations reaches the preset maximum number of iterations or the state variables of all nodes converge to a consensus value, and output the consensus value as the pixel value of the clear image after deblurring.

[0064] The present invention also provides a distributed constraint optimization system based on subgradient rescaling, comprising:

[0065] The construction module is used to construct a time-varying directed graph based on the network topology for distributed constraint optimization problems in time-varying directed networks. The time-varying directed graph satisfies consistent joint strong connectivity, and the corresponding generated weight matrix satisfies column randomness.

[0066] The initialization module is used to initialize the variables of all nodes, including state variables and auxiliary variables;

[0067] The iterative optimization module performs the following operations in each iteration: Nodes send auxiliary variables and state variables to their outgoing neighbors; Nodes receive auxiliary variables and state variables from their incoming neighbors and update the auxiliary variables and intermediate state variables based on subgradient rescaling; Based on the updated auxiliary variables and intermediate state variables, Nodes update the sub-state variables using Polyak fixed projection and Polyak random projection techniques; Then, the sub-state variables are projected onto random components of a locally compact convex constraint set to update the state variables.

[0068] The output module is used to output the globally optimal state variable when the preset stopping rules are met.

[0069] The beneficial effects of this invention are as follows:

[0070] This invention primarily addresses distributed constraint optimization problems on time-varying directed networks. In most existing dedistributed algorithms, information is transmitted through a directed network, which can lead to network imbalance. Furthermore, with the increasing development of large-scale networks, existing distributed optimization algorithms are often unsuitable for optimization problems with complex constraints. To address these problems and challenges, this invention proposes a subgradient rescaling-based distributed constraint optimization algorithm—SR-DFRP. This algorithm utilizes subgradient rescaling and distributed Polyak random projection techniques. Subgradient rescaling solves the imbalance problem caused by time-varying directed networks, while distributed Polyak random projection handles non-identical and multiple constraint sets, reducing computational load and avoiding suboptimal optimization problems, resulting in higher optimization efficiency and a wider range of applicability.

[0071] Other advantages, objectives, and features of the invention will be set forth in part in the description which follows, and in part will be apparent to those skilled in the art from the following examination, or may be learned from practice of the invention. The objectives and other advantages of the invention can be realized and obtained through the following description. Attached Figure Description

[0072] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will now be described in detail with reference to the accompanying drawings, wherein:

[0073] Figure 1 This is a flowchart illustrating the distributed constraint optimization algorithm based on subgradient rescaling of the present invention.

[0074] Figure 2 This is a schematic diagram illustrating the convergence performance of the algorithm of this invention;

[0075] Figure 3 This is a schematic diagram showing the performance comparison results between the algorithm of this invention and related algorithms;

[0076] Figure 4 This is a schematic diagram showing the performance comparison results of the algorithm of the present invention under different edge sampling probabilities in a directed network;

[0077] Figure 5 Schematic diagrams of images under different image degradation conditions;

[0078] Figure 6 This is a schematic diagram showing the deblurring results of the algorithm of this invention on images on the BSD300 dataset;

[0079] Figure 7 This is a schematic diagram of the structure of the distributed constraint optimization system based on subgradient rescaling of the present invention;

[0080] Figure 8This is a schematic diagram of the structure of a computer device according to the present invention. Detailed Implementation

[0081] The technical solution of the present invention will now be described in detail with reference to the accompanying drawings.

[0082] Figure 1 The flowchart of the algorithm described in this invention is shown in the figure. The distributed constraint optimization algorithm based on subgradient rescaling provided by this invention specifically includes the following steps:

[0083] (1) State variables for all nodes i∈V and auxiliary variables Perform initialization settings:

[0084] In this embodiment, the distributed optimization problem can be described as follows:

[0085]

[0086] in It is a non-empty closed convex set; each node i privately knows its local convex objective function f. i : and locally compact convex constraint sets Locally compact convex constraint set Λ i Describe the intersection of a finite number of convex sets, i.e. Among them O i It is the set of indices of node i; τ i >0 is a constant representing a convex function vector known only to node i, where g i,l : l∈{1,…,τ i} is g i A component of (x); It is a matrix and a vector with full row rank.

[0087] Define f * To achieve the optimal value, we introduce... and Ω0=Ω1∩…∩Ω n ,Ω * ={x∈Ω0|f(x)=f * The optimization problem satisfies the following assumption: the optimization problem has at least one finite solution x. * The feasible solution set Ω0 and the optimal solution set Ω of the optimization problem * All are nonempty and compact; locally convex objective function f i The following assumptions are satisfied:

[0088] 1)f i The subgradient ▽f at xi (x) satisfies: f i (x)-f i (y)≤▽f i (x) T (xy);

[0089] 2) Subgradient ▽f i (x), i = 1, ..., n, are uniformly bounded on the set Λ0, that is, for all state variables x ∈ Λ0 and nodes i = 1, ..., n, we have ||▽f i (x)‖≤D f , where the constant D f >0.

[0090] (2) Set the iteration count k of all nodes i∈V to 1, and set a maximum iteration count K as the criterion for stopping the algorithm to update iteratively;

[0091] (3) Randomly construct a time-varying directed network G k Generate the corresponding column random matrix It is used as a weight parameter in network communication and distributed to each node;

[0092] Optionally, a basic strongly connected directed network (containing all nodes) is first constructed as the baseline topology for the time-varying network, ensuring that it is strongly connected. In each iteration (each time t), the basic topology is randomly adjusted: for each edge in the basic network, whether to retain the edge is randomly selected with a preset edge sampling probability; the selected edges constitute the network topology at the current time t, and the unselected edges are temporarily removed at this time; for the network topology at the current time, the corresponding weight matrix is ​​generated; in the next time t+1, the steps are repeated, and edges are randomly sampled again based on the basic topology to generate a new network topology and weight matrix, thereby realizing the variable characteristics of the network.

[0093] Specifically, the constructed time-varying directed graph can be described as G k ={V,E k}, where time k≥0, and V={1,2,…,n} represents the set of nodes. Let E represent the set of edges; if node j can directly send a message to node i at time k, then edge (j,i)∈E. k Where node j is considered an incoming neighbor of node i, and correspondingly node i is an outgoing neighbor of node j; the set of incoming neighbors of node i at time k is represented as follows: The set of out neighbors of node i at time k is represented as If the in-degree of node i is not equal to its out-degree at any time k, then the time-varying directed graph G... k It is unbalanced; G k The weight matrix is ​​denoted as Where (j,i)∈E k ,but otherwise If node i is an in-neighbor of node j (i.e., there exists an edge j→i), then the weight otherwise Adjust the weight values ​​to ensure the matrix satisfies column randomness, meaning that for any node j (column index), the sum of all elements in the j-th column is 1, and all elements are non-negative; thus generating a column random matrix, namely G. k The weight matrix.

[0094] Time-varying directed network G k The following assumptions are satisfied:

[0095] 1) There exists a positive integer B such that for any time k≥0, the joint network G k ∪G k+1 ∪…∪G k+B-1 (That is, the superposition of the network topology at all times within this interval) is strongly connected, meaning that there are bidirectional paths between any nodes;

[0096] 2)G k Weight matrix A k It is a random sequence, for all nodes i,j∈V, time k≥0, we have

[0097] 3) There exists a scalar γ > 0 such that for any node i, j ∈ V, time k ≥ 0, if but

[0098] (4) Node i sends a message to its outgoing neighbor node. send and

[0099] and These are weighted auxiliary variables and weighted state variables. Weight These are coefficients introduced based on the subgradient rescaling strategy, applied to the original auxiliary variables. and state variables Scaling adjustments are made to address the imbalance problem in time-varying directed networks, compensating for information transmission deviations caused by the in-degree not equaling the out-degree. Weights For column random matrix A k The element corresponding to the j-th row and i-th column has a weight. B is a row random matrix k The elements corresponding to the j-th row and i-th column are used to construct the weights of the random matrix using a uniform weighting strategy. The specific calculation formula is as follows:

[0100]

[0101] (5) Node i starts from its ingress neighbor node Received and Next, update the auxiliary variables. and intermediate state variables The update rules are as follows:

[0102]

[0103] in, Representation matrix The element in the i-th row and j-th column of matrix B k Each element From matrix A k Each element The corresponding calculation is derived from the following formula: It is a row random matrix (the sum of the elements in each row is 1, and the elements are non-negative); α k It is a decreasing step size, satisfying and

[0104] (6) Intermediate state variables of node i By using the Polyak fixed projection idea to project onto set X i,0 Update; the update rules are as follows: If but:

[0105]

[0106] otherwise, in, i∈V, It is a constant parameter.

[0107] Global constraint set X i,0 In a distributed optimization problem, the global constraint set is the set of constraints that all nodes must adhere to. It is the intersection of the local constraint sets of all nodes (i.e., the global constraint set is the intersection of the local addressing constraints of all nodes). It is a non-empty closed convex set and the target set of the Polyak fixed projection in the algorithm. Nodes project their intermediate state variables onto the global constraint set X through the fixed projection. i,0 Projection ensures that variables satisfy global common constraints.

[0108] It should be understood that in convex optimization, "projection" refers to mapping a point to the nearest point in a set of constraints (euclidean distance can be used). For example, if an intermediate state variable exceeds the range of the global constraint set due to iterative updates, the projection operation will pull it back into the constraint set, ensuring the feasibility of the variable. Here, "fixed" means that the target set of the projection is the global constraint set X.i,0 (The intersection of all local constraints of all nodes) This set does not change over time or through random selection during algorithm iterations; it represents a "fixed" constraint standard that all nodes must always adhere to. Intermediate state variables are temporary variables updated by nodes based on neighbor information and historical data, and may deviate from global constraints due to local computation or network transmission deviations. By using fixed projection, it is ensured that the variables in subsequent iterations remain within the globally feasible region, avoiding errors in optimization direction due to constraint violations, and providing a foundation for finally converging to the global optimum.

[0109] Specifically, if the intermediate state variables do not meet the requirements of the global constraint set, they are projected onto X using the Polyak fixed projection formula. i,0 Above, obtain variables If the intermediate state variable is already in X i,0 If it is internal, no adjustment is needed; simply change the intermediate state variable directly. As Right now Regardless of how intermediate state variables are updated, they must ultimately be ensured to meet the requirements of the global constraint set through a fixed projection. This ensures that the variables of all nodes in the distributed optimization always iterate around the global feasible domain, avoiding the problem of local optimization being feasible but global infeasibility.

[0110] (7) Node i uses the Polyak random projection method to make the variable To a randomly selected local constraint set X i,l Update, obtain sub-state variables The update rules are as follows:

[0111]

[0112] in, l∈{1,…,τ i}, It is a constant parameter. It is at time k from the set of integers {1,…,τ} i A random variable randomly selected from}, if Then vector Otherwise, for a certain vector u i ≠0

[0113] In this embodiment, the Polyak projection technique (mapping variables to a constraint set through distance minimization) is used. However, the "randomness" here is reflected in the selection of the projection target. Instead of being fixed to a specific constraint set, a component is randomly selected from the local constraint set components of the node as the projection target. The variables obtained through fixed projection... (Global constraint set already satisfied); randomly select one from the local constraint set components of the node (such as "coverage constraint" and "resource allocation constraint" in location optimization, or "known pixel value constraint" in image deblurring). The local constraint set is the intersection of multiple simple convex sets. Directly processing the intersection is computationally complex. By randomly selecting a single component for projection, the computational load can be reduced. At the same time, by randomly covering different components during iteration, the variables are ultimately made to satisfy all local constraints without having to process all constraints at once.

[0114] Specifically, if Components of randomly selected local constraint sets do not meet the requirements Then, using the Polyak projection formula, Mapping onto the local constraint set component yields sub-state variables. If the condition is already met, then directly... As The local constraints of a node consist of multiple components (such as the need for location, coverage, and resource constraints to be satisfied simultaneously). In each iteration, a component is randomly selected to check and correct the variable. Through multiple iterations, all components are randomly covered, so that the variable finally satisfies all local constraints. This simplifies the single calculation and ensures the integrity of the constraints.

[0115] Through this step, the algorithm efficiently handles complex local constraints by random sampling while satisfying global constraints, avoiding the high computational cost of processing all constraints at once. At the same time, the randomness in the iteration covers all constraint components, ultimately ensuring that the variables converge to the optimal solution that satisfies both global and local constraints.

[0116] (8) Node i changes the child state variable Projected onto the locally compact convex constraint set Λ i A randomly selected component is used to obtain the updated state variables. The update rules are as follows:

[0117]

[0118] Among them, Λ i It is a locally compact convex constraint set. At time k, from set O i The random variables are randomly selected from the data. Once all nodes reach a consensus, the state variables of each node will be... It will asymptotically converge to a point in the set Ω0 in the sense of the mean.

[0119] Sub-state variables After the preceding steps (fixed projection, random projection), the global constraint set and a randomly selected local constraint component are satisfied; Π is the convex set projection operator, indicating that the projection will... Projected onto the locally compact convex constraint set Λi on; if Already in Λ i If the projection result remains unchanged (i.e., Π(p) = p); if In Λ i In addition, the projection will Pull back Λ i Inside, and the point pulled back is Λ i Zhongyu The point with the closest geometric distance (guaranteeing the minimum perturbation for correction).

[0120] For example, a locally compact convex constraint set Λ i The components include: location range constraints (e.g., "sites can only be selected within the city's second ring road"), coverage constraints (e.g., "must cover at least 3 requirement points"); if a component is randomly selected in a certain iteration. (Location range), sub-state variables It refers to the "candidate site location" (which may deviate from the Second Ring Road area due to information transmission from neighbors); projection formula You can find it within the Second Ring Road. Using the nearest point (from the deviation location) as the new location not only corrects the "out of range" problem, but also preserves the rationality of the original candidate location (nearest distance) as much as possible.

[0121] For example, a locally compact convex constraint set Λ i The components include: pixel nonnegativity constraint (Pixel value ≥ 0), known pixel value constraint (e.g., "the top 5 pixel values ​​are fixed as clear image values"); if a component is randomly selected in a certain iteration. (Known pixel values), sub-state variables It is a "pixel estimate" (the pixel value at a known location may deviate from the true value due to noise); projection formula Function: To find the pixel value that matches the given pixel value in the "set of known pixel values". The (deviation estimate) is the closest point (i.e., corrected to the true known value), which satisfies the physical constraint (the known pixel value cannot be changed) and minimizes the impact on the estimation of other pixels.

[0122] (9) Set the iteration number k to k+1. If the iteration number is less than the maximum iteration number and the state variables of all nodes have not converged to the consensus value, return to step (4) and continue to execute the algorithm until the iteration number k≥K or the state variables of all nodes converge to the consensus value. The algorithm stops running and returns the state variables of each node that have reached consensus. As the optimal solution of the objective function.

[0123] In the following embodiments, the effectiveness of the proposed algorithm and system was tested in distributed facility location scenarios and distributed image deblurring scenarios, respectively.

[0124] (1) Examples of Distributed Facility Site Selection

[0125] In many key industrial sectors, such as logistics, communications, and energy supply, the importance of distributed facility location is increasingly prominent. Taking the location of urban logistics distribution centers as an example, the complex terrain, uneven traffic flow, and significant differences in logistics demand across different areas make the location planning of distribution centers a crucial link in improving logistics efficiency and reducing costs. Inappropriate location selection may lead to extended delivery routes and increased transportation time, thereby increasing operating costs and reducing customer satisfaction. In addition, the construction costs of different facilities vary greatly due to factors such as geographical location, land prices, and infrastructure conditions, while location selection must also meet constraints such as coverage of specific areas and service populations. Traditional centralized location selection methods process all data centrally, resulting in low efficiency. The distributed facility location implementation method of this invention is designed to meet these practical needs. Through distributed processing, the need for data transmission to the central node can be effectively reduced, lowering communication costs; at the same time, by utilizing the parallel computing resources of multiple nodes, computing efficiency is significantly improved, meeting the application scenarios with high real-time requirements.

[0126] This embodiment details the implementation process of the proposed algorithm in distributed facility location selection. Experiments based on simulated data demonstrate the algorithm's efficiency and advantages in specific scenarios.

[0127] This embodiment aims to solve the distributed facility location problem. The overall goal of this embodiment is to minimize the total construction cost, where the construction cost of each facility is determined by the corresponding node, while satisfying location constraints, specific coverage requirements (inequality constraints), and resource allocation equation constraints for each facility. The specific optimization problem is as follows:

[0128]

[0129] in, It is the desired location of node i (e.g., the demand center). It is the location of the demand point j (such as the customer's coordinates), j∈D i w represents the set of demand points for services provided by node i (such as a customer area in logistics and distribution). ij >0 represents the transportation weight from node i to demand point j (which can be understood as the transportation cost per unit distance, such as fuel price, labor cost, etc.), and satisfies w ij =1 / |D i |. Set This represents the global constraint set (the intersection of all local constraints at each node, ensuring that the site selection is within the globally feasible range and that the local site selection schemes of each node are compatible at the global level, such as ensuring that all facilities cannot exceed the industrial zone boundaries of the city plan). Furthermore, each node i has a locally compact convex constraint set Λ. i =Λ i,1 ∩Λ i,2 For example, Λ i,1 =[l i ,u i ]×[v i ,w i ] can represent location range constraints; Λ i,2 ={x|‖xs i ||≤r i} can represent coverage constraints; parameters and

[0130] The core of the objective function f(x) is to minimize the total construction cost, which consists of two parts, corresponding to the sum of the facility's own construction cost and transportation cost, respectively. i || 2 Indicates the cost of facility construction. This indicates transportation costs.

[0131] Facility construction cost represents the ratio of facility location x to the desired location a of node i. i The square of the Euclidean distance between them. The closer the distance, the smaller this value, and the lower the corresponding construction cost (for example, the closer the site is to the planned demand center, the lower the land cost and infrastructure supporting costs).

[0132] Transportation cost represents the total transportation cost for a facility to provide services to all demand points j∈Di. Where:

[0133] ||x i -d j || 2 Indicates the location of the facility, x i The squared distance to the demand point j; w ij This is used for weighting (higher weighting for transportation to critical demand points, such as customers with large delivery volumes); the smaller this value, the lower the total transportation cost from the facility to the service demand point. For example, the shorter the average distance from the logistics center to the distribution point, the lower the transportation time and fuel costs.

[0134] The objective function minimizes the total global construction and transportation costs by summing the two types of costs for all nodes (facilities), which aligns with the characteristics of distributed optimization where nodes collaboratively optimize the global objective.

[0135] In the formula, x is the decision variable, representing the location parameters of the facility (such as coordinates); n is the total number of nodes (each node corresponds to a facility to be selected);

[0136] Constraints are used to limit the scope of facility site selection (to avoid site infeasibility) and are divided into equality constraints and inequality constraints, such as resource allocation constraints and coverage constraints in the corresponding embodiments.

[0137] Equality constraint: C i x = q i Resource allocation constraints refer to the rigid resource allocation requirements that facility site selection must meet (such as insurmountable resource limitations like land area and equipment capacity). i It is a full-rank resource coefficient matrix, such as the allocation coefficients of land resources and capital; q i It is a vector of total resources, such as available land area and budget ceiling; this constraint ensures that the resource consumption of the site selection scheme does not exceed the available resources of node i; for example, the land area of ​​the selected site must be equal to the area allocated to the facility in the plan.

[0138] Inequality constraints: Coverage and location constraints refer to the flexible limitations that facility site selection must meet, such as coverage area and location boundaries. This indicates that all components are less than or equal to 0 (satisfying the constraint).

[0139] The specific form of the inequality constraint is:

[0140]

[0141] Among them, D max d is the maximum allowed total distance from node i to its corresponding demand point. min It is the minimum distance between node i and its desired location. This ensures that the facility is neither too far from the demand point to be covered (first line) nor too close to an area to cause conflict (e.g., industrial facilities near residential areas need to maintain a safe distance, second line).

[0142] The total global cost is minimized by minimizing the sum of facility construction costs and transportation costs to service demand points; site selection is ensured to be feasible at the physical, resource, and planning levels through equality (resource) and inequality (coverage, location) constraints; each node only needs to know its own local objective (a i D i w ij ) and local constraints (C i q i g i (x)) By optimizing the global objective through collaborative iteration, the data concentration burden of centralized algorithms is avoided.

[0143] The subgradient rescaling-based distributed constraint optimization algorithm SR-DFRP proposed in this invention will be compared with related distributed constraint optimization algorithms in the prior art to highlight its effectiveness. The parameter settings for each algorithm are as follows:

[0144] Example 1

[0145] The algorithm of this invention is used for calculation, with the number of nodes set to n=5 and the required point D. i Given a random distribution on the plane [0,10]×[0,10], a i The coordinates of the center of the region where node i is located, and the transport weight w ij =1 / |D i Regarding constraints, for all nodes i, the problem parameters are set as follows: l i =2, u i =8, v i =3, w i =7,s i =a i r i =3,D max =50,d min =10, C i =[1,-1] and q i =0.

[0146] The lower and upper bounds of the facility location at node i on the x-axis, i.e., the components of the facility coordinates, must satisfy l. i ≤x≤u i (e.g., x∈[2,8]), avoid site selection outside the core planning area (e.g., the boundary between the city center and the suburbs). The lower and upper bounds of the facility location of node i on another coordinate axis (e.g., the y-axis) are related to l. i u i Together they form a two-dimensional position-constrained rectangular region [l i ,u i ]×[v i ,w i (i.e., x∈[2,8] and y∈[3,7]), further narrowing the spatial range of the site selection.

[0147] s i It is the reference position of node i; r i =3 is the minimum distance between the facility and the reference location (e.g., ||x) i -s i ||≥3), used to avoid conflict, such as avoiding facilities being too close to sensitive areas such as residential areas and schools, and maintaining a safe distance of at least 3 units.

[0148] D max=50 means that the maximum allowed total distance from the facility of node i to all demand points it serves is 50, ensuring that the facility can effectively cover all demand points (a total distance exceeding 50 is considered insufficient coverage and does not meet the constraint).

[0149] d min =10 indicates that the resource limit related to facility construction of node i is 10, such as the maximum available land area, construction budget, etc. It is used to quantify the threshold of resource constraints. The specific meaning needs to be flexibly determined in combination with the resource type, such as the land area limit being 10 units.

[0150] C i =[1,-1] and q i =0, based on the aforementioned equality constraint C i x = q i The resource allocation relationship used to restrict the location of facilities: Substituting, we get 1x1+(-1)x2=0 (i.e., x1=x2), which means that the x-coordinate and y-coordinate of the facility must be equal, simulating the rigid requirements of resource allocation in reality, such as the need for the facility to be built on a certain diagonal line due to terrain restrictions.

[0151] For the network, first, a directed network G (with high network sparsity) with n=5 nodes is randomly constructed, ensuring it is strongly connected. Then, at each time k, each edge in network G is randomly and uniformly sampled with a 30% probability, thus forming a new network G. k This is a time-varying directed network. Based on this process, the time-varying directed graph G can be ensured. k It is B-strongly connected.

[0152] Furthermore, in this embodiment, a step size α is set for all times k≥0. k = 0.5 / (k+1). The iteration step size is the adjustment range when the algorithm updates variables. In this embodiment, it is a decreasing step size (which decreases as the number of iterations k increases), satisfying... and The convergence condition is as follows: In the early stages, the step size is larger to quickly approach the optimal solution; in the later stages, the step size is smaller to stably converge to the optimal value.

[0153] Then, complete the distributed facility site selection process by following these steps:

[0154] (1) State variables of 5 nodes and auxiliary variables Perform initialization settings: The iteration count k for the 5 nodes is set to 1, and a maximum iteration count K = 1000 is set as the criterion for the algorithm to stop iterating and updating.

[0155] (2) Randomly construct a time-varying directed graph G k Generate the corresponding column random matrix It is used as a weight parameter in network communication and distributed to each node;

[0156] (3) Node i sends a message to its outgoing neighbor node. send and

[0157] (4) Node i starts from its ingress neighbor node Received and Next, update the auxiliary variables. and intermediate state variables The update rules are as follows:

[0158]

[0159] in, Representation matrix The elements in the i-th row and j-th column are a row random matrix; α k It is a decreasing step size, satisfying and

[0160] (5) Intermediate state variables of node i By using the Polyak fixed projection idea to project onto set X i,0 Update, the update rules are as follows: If but:

[0161]

[0162] otherwise in, i∈V, It is a constant parameter;

[0163] (6) Node i uses the Polyak random projection method to make the variables... To a randomly selected set X i,l Update, the update rules are as follows:

[0164]

[0165] in, l∈{1,…,τ i}, It is a constant parameter. It is at time k from the set of integers {1,…,τ} i A random variable randomly selected from}, if Then vector Otherwise, for a certain vector u i ≠0

[0166] (7) Node i changes variables Projected onto the locally compact convex constraint set Λ i A randomly selected component is used to obtain the updated state variables. The update rules are as follows:

[0167]

[0168] in, At time k, from set O i The random variables are randomly selected from the data. Once all nodes reach a consensus, the state variables of each node will be... It will asymptotically converge to a point in the set Ω0 in the sense of the mean;

[0169] (8) Set the iteration number k to k+1. If the iteration number is less than the maximum iteration number, return to step (3) and continue to execute the algorithm process until the iteration number k≥K or converges, and the algorithm stops running.

[0170] (9) After the algorithm finishes running, the state variables of all nodes After K iterations, a consensus is reached. Substituting the state variable values ​​of all nodes yields the optimal solution to the objective function, which is the minimum total construction cost.

[0171] Comparative Example 1

[0172] The calculation is performed using existing distributed constraint optimization algorithms, with the same problem parameters, network parameters, step size parameters, and initial state variables as in Example 1.

[0173] In the network environment constructed in this simulation experiment, the relevant parameters of Example 1 and Comparative Example 1 obtained through optimal modulation under the same conditions are specific and targeted. It should be emphasized that in actual applications, due to the complexity and diversity of different network environments and data conditions, the corresponding optimal modulation parameters will also change, and cannot be generalized.

[0174] In actual implementation, each node in the system is based on the time-varying directed network G. k The system communicates through connections and continuously updates state variables based on the iterative steps of each algorithm. Output the state variable x of each node when the maximum number of iterations is reached or convergence is achieved. i The optimal solution to the overall objective function is obtained by substituting the optimal solution of each node and calculating the minimum total construction cost of the distributed facility location problem.

[0175] In this embodiment, the convergence performance of the SR-DFRP algorithm was first verified. By comparing it with a known related algorithm that can effectively solve the problem in the same environment (problem parameters and network parameters) (Comparative Example 1), it was proven that the SR-DFRP algorithm can successfully converge to the optimal solution. Figure 2 As shown, the state variables of node 3 are selected. The convergence trajectory (two-dimensional) is displayed, demonstrating the correctness of the SR-DFRP algorithm's convergence result, and the state variables of other nodes also exhibit a similar convergence trend. Secondly, the convergence rate of the SR-DFRP algorithm is evaluated and compared with related algorithms. Figure 3 As shown, the convergence rate of the SR-DFRP algorithm is comparable to, or even slightly better than, other related algorithms, especially in time-varying directed network environments. The superiority of the SR-DFRP algorithm stems from its strategy for handling network imbalance. Furthermore, compared to the imprecise gradient tracking strategy employed by related algorithms, the SR-DFRP algorithm requires no additional gradient storage, thus avoiding the slowdown in convergence speed caused by increased storage requirements.

[0176] Furthermore, this embodiment also explores the impact of network connectivity on the convergence performance of the SR-DFRP algorithm. By changing the sampling probability of the network (keeping other parameters the same as in the first part), it was found that network connectivity has a significant impact on the convergence rate of the SR-DFRP algorithm. Figure 4 As shown, the convergence speed of the SR-DFRP algorithm increases significantly as the network becomes denser (i.e., the sampling probability of each edge increases). This indicates that the SR-DFRP algorithm can achieve convergence more efficiently in a more connected network environment.

[0177] (2) Distributed Image Deblurring Implementation Example

[0178] Image deblurring technology is becoming increasingly important in many technological fields, including video surveillance, medical imaging, and autonomous driving. Taking in-vehicle camera images in autonomous driving as an example, factors such as vehicle bumps, adverse weather conditions, and complex lighting environments often lead to blurred images. This blurring not only reduces image clarity but also makes it difficult to accurately extract key information, thus affecting the decision-making efficiency and safety of the autonomous driving system. Furthermore, the degree of blurring varies between images captured by different cameras, and the image data volume is enormous. Traditional centralized deblurring methods require transmitting all image data to a central server for processing, resulting in low efficiency. Therefore, the distributed image deblurring embodiment proposed in this invention aims to solve these practical problems. Through distributed processing, the centralized transmission of large amounts of image data to a central node is avoided, thereby reducing communication costs; simultaneously, utilizing the computing resources of multiple nodes to process tasks in parallel significantly improves computational efficiency, meeting the needs of applications with high real-time requirements.

[0179] This embodiment details the application process of the proposed algorithm and system in distributed image deblurring scenarios. Experiments based on a real image dataset (BSD300 dataset) systematically verify the effectiveness and advantages of the proposed algorithm in this specific scenario.

[0180] This embodiment aims to solve the distributed image deblurring problem. In the image deblurring problem, a clear image is formed by a matrix... It is represented and then reshaped into a vector. in This refers to the image size. The linear degradation process of a sharp image can be modeled as:

[0181] y = Ax + b,

[0182] in It is a degradation operator that incorporates the inherent blurring effect during the imaging process. It is additional noise. This represents the observed blurred image. Different degradation operators A and noise b represent different scenarios. For example, when A = I, y is an image in a sharp image x that has been contaminated by added noise b. When the degradation operator A is a blur kernel convolution and the noise b is added Gaussian white noise, y is an image whose image quality is degraded due to the relative displacement between the sensor and the object during the imaging process. Figure 5 Image examples are provided for different degradation scenarios.

[0183] The overall goal of this experiment is to find an estimate of the state variable x, given the degradation operator A and the degradation image y. The general form of this optimization problem can be expressed as:

[0184]

[0185] The core of the objective function is to recover a clear image from a degraded image. This is achieved through two parts: one part ensures the good fit between the recovered image and the degraded image, and the other part avoids overfitting during the recovery process, as detailed below:

[0186] x represents the decision variable, symbolizing the pixel values ​​of the sharp image to be restored (in vector form, reconstructed from the image matrix); n represents the total number of nodes (each node stores a locally degraded image and its corresponding blur kernel); A i It is the fuzzy matrix (degeneracy operator) of node i, simulating the fuzzy effect in the imaging process (such as the convolution kernel matrixization of motion blur);

[0187] It is the degenerate image (vector form) of node i; the l1 regularization term χ||x||1 (χ>0) encourages sparse solutions, which helps feature selection and enhances the interpretability of the model. Constraint C i x = q i It introduces boundary constraints based on known physical or prior information (e.g., a subset of pixel values ​​in an image). Furthermore, (τ i >0 is a constant) is a convex function vector, a is a positive vector, Λ0 is the global constraint set, belongs to the box constraint set, is the intersection of all node local constraints, and ensures that the restoration result conforms to the physical rules at the global level.

[0188] The objective function consists of a data fitting term and a regularization term, which together achieve the goals of accurate data recovery and noise suppression. The data fitting term is determined by... The expression represents the fitting error between the blurred image and the degraded image. The core idea is to pass the clear image x through the blur matrix A. i After simulating the degradation process, the degraded image y should be as close as possible to the actual acquired image. i . This is the square of the Euclidean distance, quantifying the difference between the restored image after degradation and the actual degraded image. Summing over all nodes is because in a distributed scenario, each node is responsible for restoring the locally degraded image, ultimately collaboratively optimizing the globally clear image x. The smaller this term is, the closer the restored clear image is to the real blurred image after degradation, meaning the degradation process is accurately reversed.

[0189] The regularization term, represented by χ||x||1, signifies a sparsity constraint on the reconstructed image x. Its core purpose is to suppress noise and overfitting, thereby enhancing the stability of the reconstruction result. ||x||1 is the L1 norm (the sum of the absolute values ​​of all pixels), encouraging unimportant pixel values ​​in the image to approach 0 (sparseness), such as removing noise from blurring and preserving key features like edges. χ is used to balance the fitting term and the regularization term: a larger χ emphasizes noise suppression (but may blur edges); a smaller χ emphasizes fitting the degraded image (but may preserve noise).

[0190] The objective function is based on the sum of data fitting terms and regularization terms. By minimizing degradation loss and controlling sparsity, it can remove blur and noise while preserving key image features, which meets the core requirement of image deblurring.

[0191] Constraints are used to limit the range of pixel values ​​in the recovered image (to avoid meaningless results) and are divided into equality constraints and inequality constraints, corresponding to the known pixel value constraints and pixel non-negativity constraints in the embodiments.

[0192] Where the equality constraint C i x = q i , representing a known pixel value constraint, is used to force the values ​​of known pixels in the recovered image to be fixed, thereby improving the recovery accuracy by utilizing prior information. C i This is a selection matrix, where a row is set to 1 only at known pixel positions and 0 elsewhere. q i It is a vector of known pixel values; for example, each node knows the pixel value of the 1×5 region in the upper left corner of the clear image; this constraint ensures that the pixel value of the restored image in the known region is consistent with the true value. For example, if the pixel value of the upper left corner of the image is known to be 255, then the value of that position in the restored result must be 255.

[0193] Inequality constraints: This represents a physical rationality constraint, used to limit the pixel values ​​of the recovered image to conform to physical rules (such as non-negativity, brightness range, etc.); This means that all components are less than or equal to a (satisfying the constraint).

[0194] Since the range of image pixel values ​​is usually [0, 255], and pixel values ​​cannot be negative, it is converted to... The form is:

[0195]

[0196] Where x1, x2, ..., x m It restores the pixel values ​​of the image; this constraint ensures that all pixel values ​​x j ≥0, which conforms to the physical characteristics of image pixels.

[0197] Accurate restoration of a clear image is achieved by minimizing the error between the degraded and blurred images (fitting term) and suppressing noise (L1 regularization term). Known pixel values ​​(equality constraints) and physical plausibility (inequality constraints) ensure that the restoration result not only fits numerically but also conforms to the characteristics of the actual image (e.g., non-negative pixels, accurate known regions). Each node only needs to process its own locally degraded image (A). i ,y i ) and local constraints (C i ,q i By collaboratively iteratively optimizing the globally clear image x, the burden of centralized transmission and processing of large-scale image data is avoided by centralized algorithms.

[0198] Example 2

[0199] The algorithm of this invention is used for calculation. Consider a network consisting of n=10 nodes in a time-varying directed network G. k This paper evaluates the performance of the SR-DFRP algorithm using five 64×64 images from the BSD300 dataset and common image deblurring metrics: Peak Signal-to-Noise Ratio (PSNR), Structural Similarity Index (SSIM), and Loss Value (LOSS). Blurred images are generated by convolving the sharp image with Gaussian noise (variance = 0.01) and motion blur (variance = 2). The global constraint set x∈Λ0 is chosen to be a non-negativity constraint x≥0, and the function g... i (x) is the l1 norm to ensure the solvability of the optimization problem. Furthermore, it is assumed that each node i knows the pixel values ​​of the top-left 1×5 region of the sharp image. Therefore, matrix C... i sum vector q i C can be set for all nodes i based on different image clarity settings. i =C and q i =q. For all times k≥0, the step size α k Select in descending order.

[0200] Then, follow these steps to complete the distributed image deblurring process:

[0201] (1) Each node i stores a degraded image y. i And the corresponding motion convolution blur kernel H i State variables of 10 nodes and auxiliary variables Perform initialization settings: The iteration count k for the 10 nodes is set to 1, and a maximum iteration count K = 1000 is set as the criterion for the algorithm to stop iterating and updating.

[0202] (2) Randomly construct a time-varying directed network Gk Generate the corresponding column random matrix It is used as a weight parameter in network communication and distributed to each node;

[0203] (3) Node i sends a message to its outgoing neighbor node. send and

[0204] (4) Node i starts from its ingress neighbor node Received and Next, update the auxiliary variables. and intermediate state variables The update rules are as follows:

[0205]

[0206] in, Representation matrix The elements in the i-th row and j-th column are a row random matrix; α k It is a decreasing step size, satisfying and

[0207] (5) Intermediate state variables of node i By using the Polyak fixed projection idea to project onto set X i,0 Update, the update rules are as follows: If but:

[0208]

[0209] otherwise in, i∈V, It is a constant parameter;

[0210] (6) Node i uses the Polyak random projection method to make the variables... To a randomly selected set X i,l Update, the update rules are as follows:

[0211]

[0212] in, l∈{1,…,τ i}, It is a constant parameter. It is at time k from the set of integers {1,…,τ} i A random variable randomly selected from}, if Then vector Otherwise, for a certain vector u i ≠0

[0213] (7) Node i changes variables Projected onto the locally compact convex constraint set Λ i A randomly selected component is used to obtain the updated state variables. The update rules are as follows:

[0214]

[0215] in, At time k, from set O i The random variables are randomly selected from the data. Once all nodes reach a consensus, the state variables of each node will be... It will asymptotically converge to a point in the set Ω0 in the sense of the mean;

[0216] (8) Set the iteration number k to k+1. If the iteration number is less than the maximum iteration number and has not converged, return to step (3) to continue the algorithm process until the iteration number k≥K or converges, and the algorithm stops running.

[0217] (9) After the algorithm finishes running, the state variables of all nodes After K iterations, a consensus is reached, and at this point, the state variable values ​​of all nodes are the clear image after deblurring.

[0218] In the network environment constructed in this simulation experiment, the relevant parameters of Example 1 obtained through optimal modulation under the same conditions are specific and targeted. It should be emphasized that in actual applications, due to the complexity and diversity of different network environments and data conditions, the corresponding optimal modulation parameters will also change, and cannot be generalized.

[0219] In actual implementation, each node in the system is based on the time-varying directed network G. k The system communicates through connections and continuously updates state variables based on the iterative steps of each algorithm. When the maximum number of iterations is reached, output the state variable x of each node. i This is the optimal solution to the overall objective function, which is the final clear image obtained from the distributed image deblurring experiment.

[0220] In this embodiment, the experimental results are as follows: Figure 6The deblurring effect of the SR-DFRP algorithm was visualized, showing that five blurred images with Gaussian noise and motion blur could be successfully restored, indicating the effectiveness of the SR-DFRP algorithm in distributed image deblurring problems. Table 1 shows the simulated results of PSNR, SSIM, and loss values ​​of the SR-DFRP algorithm on clear, blurred, and deblurred images, further verifying that its performance is significantly improved compared to degraded images, specifically manifested in the increase of PSNR and SSIM and the reduction of loss values.

[0221] Table 1 shows the PSNR, SSIM, and LOSS results for the clear image, the blurred image, and the image deblurred using the algorithm of this invention.

[0222] Clear image (a) (b) (c) (d) (e) PSNR inf inf inf inf inf SSIM 1 1 1 1 1 LOSS 658.36 185.31 341.41 365.47 306.57 Blurry image (a) (b) (c) (d) (e) PSNR 18.67 17.29 15.76 17.21 18.59 SSIM 0.401 0.337 0.323 0.312 0.367 LOSS 701.77 210.85 477.27 371.64 345.17 Deblurred image (a) (b) (c) (d) (e) PSNR 29.21 29.61 31.04 31.14 28.54 SSIM 0.961 0.983 0.989 0.978 0.951 LOSS 642.81 165.17 325.06 340.32 283.06

[0223] Finally, Table 2 shows the deblurring effect of the SR-DFRP algorithm under different blur variances. The results show that the PSNR and SSIM indices only decrease slightly, while the loss value increases slightly, thus verifying the robustness of the SR-DFRP algorithm to different blurred images.

[0224] Table 2 shows the deblurring results of the algorithm of this invention on images under different fuzziness variances.

[0225] Variance = 1 (a) (b) (c) (d) (e) PSNR 33.31 34.54 33.59 31.76 32.35 SSIM 0.978 0.993 0.985 0.989 0.963 LOSS 650.61 178.12 347.72 340.85 287.21 Variance = 2 (a) (b) (c) (d) (e) PSNR 29.21 29.61 31.04 31.14 28.54 SSIM 0.961 0.983 0.989 0.978 0.951 LOSS 642.81 165.17 325.06 340.32 283.06 Variance = 3 (a) (b) (c) (d) (e) PSNR 27.84 30.41 29.65 29.54 28.06 SSIM 0.954 0.985 0.981 0.988 0.948 LOSS 639.59 166.33 314.28 340.21 283.32

[0226] Based on the above algorithm implementation, this embodiment also provides a subgradient rescaling-based distributed constraint optimization system, which can be used to implement the steps of the above algorithm.

[0227] refer to Figure 7 The distributed constraint optimization system based on subgradient rescaling includes:

[0228] Module 71 is used to construct a time-varying directed graph based on the network topology for distributed constraint optimization problems in time-varying directed networks. The time-varying directed graph satisfies consistent joint strong connectivity, and the corresponding generated weight matrix satisfies column randomness.

[0229] Initialization module 72 is used to initialize the variables of all nodes, including state variables and auxiliary variables;

[0230] The iterative optimization module 73 is used to perform the following operations in each iteration: the node sends auxiliary variables and state variables to its outgoing neighbors; the node receives auxiliary variables and state variables from its incoming neighbors and updates the auxiliary variables and intermediate state variables based on the subgradient rescaling technique; the node updates the substate variables based on the updated auxiliary variables and intermediate state variables by using Polyak fixed projection and Polyak random projection techniques; and then projects the substate variables onto random components of the locally compact convex constraint set to update the state variables.

[0231] Output module 74 is used to output the globally optimal state variable when the preset stopping rules are met.

[0232] The various variations and specific examples of the algorithm provided in the above embodiments are also applicable to the system of this embodiment. Through the foregoing detailed description of the algorithm, those skilled in the art can clearly understand the implementation method of the system in this embodiment. For the sake of brevity, they will not be described in detail here.

[0233] To better execute the above methods, embodiments of this application also provide a computer device, such as... Figure 8 As shown, the computer device includes a processor, a memory, and a communication bus for enabling communication between the processor and the memory.

[0234] Computer devices can take many forms, including mobile phones, tablets, handheld computers, laptops, and desktop computers.

[0235] The memory can be used to store instructions, programs, code, code sets, or instruction sets. The memory may include a program storage area and a data storage area. The program storage area may store instructions for implementing an operating system, instructions for at least one function, and instructions for implementing the methods provided in the above embodiments; the data storage area may store data involved in the methods provided in the above embodiments.

[0236] Optionally, the memory may be a read-only memory (ROM), random access memory (RAM), electrically erasable programmable read-only memory (EEPROM), optical disc (including compact disc read-only memory (CD-ROM), compressed optical disc, laser disc, digital versatile optical disc, Blu-ray disc, etc.), magnetic disk storage medium, or other magnetic storage device, or any other medium capable of carrying or storing desired program code in the form of instructions or data structures and accessible by a computer, but not limited to these. The memory exists independently and is connected to the processor via a communication bus, or the memory is integrated with the processor.

[0237] A processor may include one or more processing cores. The processor executes instructions, programs, code sets, or instruction sets stored in memory, and calls data stored in memory to perform various functions and process data as described in this application. The processor may be at least one of the following: Application Specific Integrated Circuit (ASIC), Digital Signal Processor (DSP), Digital Signal Processing Device (DSPD), Programmable Logic Device (PLD), Field Programmable Gate Array (FPGA), Central Processing Unit (CPU), controller, microcontroller, and microprocessor. It is understood that, for different devices, the electronic devices used to implement the above-described processor functions may also be other types, and the embodiments of this application do not specifically limit this.

[0238] The communication bus can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. This communication bus can be divided into address bus, data bus, control bus, etc. For ease of illustration, only one thick line is used to represent it in the diagram, but this does not mean that there is only one bus or one type of bus.

[0239] In an alternative embodiment, the computer device may further include a communication interface (not shown) for communication with other devices.

[0240] This application provides a computer-readable storage medium, including, for example, various media capable of storing program code such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk. This computer-readable storage medium stores a computer program that can be loaded by a processor and execute the methods of the above embodiments.

[0241] This application also provides a computer program product comprising a computer program tangibly embodied on a readable medium thereof, the computer program containing program code for performing any of the methods described in any of the embodiments of this application, the computer program being downloadable and installable over a network, and / or installed from a removable medium (such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc.).

[0242] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications can be made to the technical solutions of the present invention without departing from the spirit and scope of the present invention, and all such modifications should be covered within the scope of the claims of the present invention.

Claims

1. A distributed constraint optimization algorithm based on subgradient rescaling, characterized in that, Includes the following steps: S1: For the distributed constraint optimization problem in time-varying directed networks, a time-varying directed graph is constructed based on the network topology. The time-varying directed graph satisfies consistent joint strong connectivity, and the corresponding generated weight matrix satisfies column randomness. S2: Initialize all node variables, including state variables and auxiliary variables; S3: In each iteration, perform the following operations: The node sends auxiliary variables and state variables to its outgoing neighbors; the node receives auxiliary variables and state variables from its incoming neighbors and updates the auxiliary variables and intermediate state variables based on the subgradient rescaling technique; the node updates the substate variables based on the updated auxiliary variables and intermediate state variables by using Polyak fixed projection and Polyak random projection techniques; then the substate variables are projected onto random components of the locally compact convex constraint set to update the state variables. S4: Repeat step S3 until the preset stopping rule is met, and output the globally optimal state variable.

2. The optimization algorithm according to claim 1, characterized in that, The distributed optimization problem is: in It is a non-empty closed convex set; each node i privately knows its local convex objective function. and locally compact convex constraint sets Locally compact convex constraint set Λ i Describe the intersection of a finite number of convex sets, i.e. Among them O i It is the set of indices of node i; τ i >0 is a constant representing a convex function vector known only to node i, where It is g i A component of (x); It is a matrix and a vector with full row rank. Define f * To achieve the optimal value, we introduce... and Ω0=Ω1∩…∩Ω n ,Ω * ={x∈Ω0|f(x)=f * The optimization problem satisfies the following assumption: the optimization problem has at least one finite solution x. * The feasible solution set Ω0 and the optimal solution set Ω of the optimization problem * All are nonempty and compact; locally convex objective function f i The following assumptions are satisfied: 1)f i The subgradient at x satisfy: 2) Subgradient The set Λ0 is uniformly bounded, meaning that for all state variables x∈Λ0 and nodes i=1,...,n, the following holds: Where the constant D f >0.

3. The optimization algorithm according to claim 2, characterized in that, The time-varying directed graph constructed in step S1 can be described as G k ={V,E k }, where time k≥0, and V={1,2,…,n} represents the set of nodes. Let E represent the set of edges; if node j can directly send a message to node i at time k, then edge (j,i)∈E. k Where node j is considered an incoming neighbor of node i, and correspondingly node i is an outgoing neighbor of node j; the set of incoming neighbors of node i at time k is represented as follows: The set of out neighbors of node i at time k is represented as If the in-degree of node i is not equal to its out-degree at any time k, then the time-varying directed graph G... k It is unbalanced; G k The weight matrix is ​​denoted as Where (j,i)∈E k ,but otherwise G k The following assumptions are satisfied: 1) There exists a positive integer B such that for any time k≥0, the joint network G k ∪G k+1 ∪…∪G k+B-1 It is strongly connected; 2)G k Weight matrix A k It is a random sequence, for all nodes i,j∈V, time k≥0, we have 3) There exists a scalar γ > 0 such that for any node i, j ∈ V, time k ≥ 0, if but 4. The optimization algorithm according to claim 3, characterized in that, In step S2, initializing the variables of all nodes specifically includes: S21: Initialize the variables of all nodes i∈V as follows: state variables Initialize to Auxiliary variables Initialize to 5. The optimization algorithm according to claim 4, characterized in that, Step S3 includes: S301: Set the iteration count k for all nodes i∈V to 1, and set a maximum iteration count K as the criterion for stopping the algorithm's iteration update; S302: Transform the time-varying directed network G k Corresponding column random matrix It is used as a weight parameter in network communication and distributed to each node; S303: Node i sends a message to its outgoing neighbor node. send and S304: Node i's incoming neighbor node Received and Next, update the auxiliary variables. and intermediate state variables The update rules are as follows: in, Representation matrix The elements in the i-th row and j-th column are a row random matrix; α k It is a decreasing step size, satisfying and S305: Intermediate state variable of node i By using the Polyak fixed projection concept to project onto the global constraint set X i,0 Projection, update to obtain variables The update rules are as follows: if but: otherwise in, It is a constant parameter; S306: Node i uses the Polyak random projection concept to make the variable... To a randomly selected local constraint set X i,l Update, obtain sub-state variables The update rules are as follows: in, It is a constant parameter. It is at time k from the set of integers {1,…,τ} i A random variable randomly selected from}, if Then vector Otherwise, for a certain vector u i ≠0 S307: Node i passes the child state variable Projected onto the locally compact convex constraint set Λ i On a randomly selected component, to obtain the updated state variable The update rules are as follows: in, At time k, from set O i Random variables randomly selected from the data; once all nodes reach a consensus, the state variables of each node... It will asymptotically converge to a point in the set Ω0 in the sense of the mean; S308: Set the iteration count k to k+1. If the iteration count is less than the maximum iteration count and the state variables of all nodes have not converged to the consensus value, return to step S303 to continue executing the algorithm until the iteration count k≥K or the state variables of all nodes converge to the consensus value. The algorithm then stops running and returns the state variables of each node that have reached consensus. As the optimal solution of the objective function.

6. A location optimization method based on subgradient rescaling distributed constraints, characterized in that, The distributed node location collaborative optimization is achieved based on the optimization algorithm described in any one of claims 1 to 5, including the following steps: S1: For the distributed addressing optimization problem in time-varying directed networks, a time-varying directed graph is constructed based on the network topology, ensuring that the time-varying directed graph satisfies consistent joint strong connectivity and that the corresponding generated weight matrix satisfies column randomness. The distributed addressing optimization problem aims to minimize the total construction cost. Each node corresponds to a local addressing objective function and a local compact convex constraint set. The local compact convex constraint set includes at least one of location range constraints, coverage range constraints, and resource allocation constraints. The specific objective function is as follows: in, It is the desired position of node i. It is the location of demand point j, j∈D i Let w represent the set of demand points served by node i, and w ij >0 represents the transportation weight from node i to demand point j; S2: Initialize the variables of all nodes, including local addressing state variables and auxiliary variables, wherein the local addressing state variables represent the candidate addressing location parameters of the nodes; S3: Perform the following operations at each iteration: S301: The node sends the current auxiliary variables and local addressing status variables to its outgoing neighbor node; S302: The node receives auxiliary variables and local addressing state variables from the incoming neighbor nodes, and updates its own auxiliary variables and intermediate state variables according to the preset update rules based on the subgradient rescaling technique and the weight parameters of the random matrix. S303: Nodes use the Polyak fixed projection method to project intermediate state variables onto the global constraint set X. i,0 Projection, update to obtain variables The global constraint set X i,0 The intersection of all local addressing constraints for all nodes; S304: Nodes use the Polyak random projection method to transform variables. To a randomly selected local constraint set X i,l Projection and update yield sub-state variables S305: The node will change the child state variable Project the updated local addressing state variables onto a randomly selected component of the local addressing constraint set. S4: Repeat step S3 until the number of iterations reaches the preset maximum number of iterations or the local addressing state variables of all nodes converge to the consensus value, and output the consensus value as the optimal addressing location parameter.

7. An image deblurring method based on subgradient rescaling distributed constraints, characterized in that, Distributed node collaborative image deblurring based on the optimization algorithm described in any one of claims 1 to 5 includes the following steps: S1: For the distributed image deblurring problem in time-varying directed networks, a time-varying directed graph is constructed based on the network topology, ensuring that the time-varying directed graph satisfies consistent joint strong connectivity and that the corresponding generated weight matrix satisfies column randomness; the image deblurring problem aims to minimize image degradation loss, with each node storing the local degraded image and the corresponding blur kernel, and possessing a private locally convex objective function and a locally compact convex constraint set. The specific objective function includes: in, It is the degenerate operator of node i. Let be the degenerate image of node i, and let χ be the coefficient of the l1 regularization term; S2: Initialize all node variables, including the state variable x. k and auxiliary variables State variable x k Pixel estimates that characterize the image deblurring process; S3: Perform the following operations at each iteration: S301: The node sends its current auxiliary variables and state variables to its outgoing neighbor node; S302: The node receives auxiliary variables and state variables from the incoming neighbor nodes, and updates its own auxiliary variables and intermediate state variables according to the preset update rules based on the subgradient rescaling technique and the weight parameters of the row random matrix. S303: Nodes use the Polyak fixed projection method to project intermediate state variables onto the global constraint set, updating the variables. S304: Nodes use the Polyak random projection method to transform variables. Projecting onto a randomly selected set of local constraints, the sub-state variables are updated. S305: The node will change the child state variable Projecting onto a randomly selected component of a locally compact convex constraint set, the updated state variables are obtained. S4: Repeat step S3 until the number of iterations reaches the preset maximum number of iterations or the state variables of all nodes converge to a consensus value, and output the consensus value as the pixel value of the clear image after deblurring.

8. A distributed constraint optimization system based on subgradient rescaling, characterized in that, include: The construction module is used to construct a time-varying directed graph based on the network topology for distributed constraint optimization problems in time-varying directed networks. The time-varying directed graph satisfies consistent joint strong connectivity, and the corresponding generated weight matrix satisfies column randomness. The initialization module is used to initialize the variables of all nodes, including state variables and auxiliary variables; The iterative optimization module performs the following operations during each iteration: the node sends auxiliary variables and state variables to its outgoing neighbors; Nodes receive auxiliary and state variables from their incoming neighbors and update them using subgradient rescaling. Based on the updated auxiliary and intermediate state variables, nodes update their substate variables using Polyak fixed projection and Polyak random projection techniques. Then, they project the substate variables onto random components of a locally compact convex constraint set to update the state variables. The output module is used to output the globally optimal state variable when the preset stopping rules are met.

Images