A learning-based disturbed observation constrained optimization method and system with final arbitration

Abstract

The application relates to the technical field of distributed control, and discloses a learning type disturbed observation constraint optimization method and system with final arbitration, which comprises the following steps: encapsulating optimization operations in a distributed system as events, constructing a hash directed acyclic graph event log, setting a final arbitration node to release a staged event, generating a deterministic execution sequence, executing an iterative recovery algorithm, outputting a recovery result and an observation uncertainty index, constructing a continuous weight mapping function, integrating weights into an original function to convert the original function into a robust corresponding function, generating a candidate solution by adopting a two-stage process, and generating a parameter submission taking effect event and writing the event into the event log when the candidate solution meets real robust constraints and improves a real robust target. The application can prevent optimization trajectories from being contaminated by rollback, improves constraint satisfaction stability, reduces the number of real evaluation times and improves the feasible improvement rate under the same budget, and reduces the risk of strategy contamination by noise and concurrency.

Description

Technical Field

[0001] This invention relates to the field of distributed control technology, and in particular to a learning-based disturbed observation constraint optimization method and system with final arbitration. Background Technology

[0002] In scenarios such as distributed edge systems, broadband receiving systems, and online policy parameter tuning systems, the evaluation of objective functions and constraint functions often relies on online experiments, business closed-loop feedback, or high-cost simulations, with limited evaluation budgets. At the same time, the observed data may suffer from saturation, quantization, nonlinear distortion, and strong adjacent-channel interference, leading to unstable evaluation inputs.

[0003] Furthermore, distributed concurrent updates are prone to state rollback or manipulation under network partitioning, out-of-order delivery, and latency jitter, polluting the optimization trajectory and causing inconsistent parameter activation order. Therefore, a unified and collaborative solution is urgently needed that simultaneously ensures observation stabilization, evaluation efficiency, and eventual consistent effectiveness. Summary of the Invention

[0004] In view of the aforementioned existing problems, this invention is proposed. Therefore, this invention provides a learning-based perturbed observation constraint optimization method with finality arbitration to solve the above problems.

[0005] To solve the above-mentioned technical problems, the present invention provides the following technical solution: In a first aspect, the present invention provides a learning-based perturbed observation constraint optimization method with final arbitration, comprising: Encapsulate optimization operations in distributed systems as events and construct a hash-directed acyclic graph event log; Based on the hash-directed acyclic graph event log, a final arbitration node is set up, and phased events are published through the final arbitration node. Each participating node generates a deterministic execution sequence based on the phased events. For the disturbed data in the observed events, an iterative recovery algorithm is executed, the recovery results and observation uncertainty indicators are output, and the recovery events are generated and written to the event log; Based on the observation uncertainty index, a continuous weight mapping function is constructed, the weights are integrated into the original function to convert it into a robust corresponding function, a surrogate model pool is maintained to approximate the robust corresponding function, and a two-stage process is used to generate candidate solutions. When the candidate solution satisfies the true robustness constraint and improves the true robustness objective, a parameter submission effective event is generated and written to the event log, and the execution node applies the updated parameters under the phased event containing the submission effective event and the corresponding boundary of its phased boundary front.

[0006] As a preferred embodiment of the learning-based disturbed observation constraint optimization method with final arbitration as described in this invention, the optimization operations in the distributed system are encapsulated as events, and a hash-directed acyclic graph event log is constructed, including: Encapsulate operations related to observation, recovery, evaluation, candidate generation, parameter submission and activation, and rollback in a distributed system as events; The event shall include at least an event identifier, a parent event set, an event type, and a payload summary; When a new event occurs, a hashed directed acyclic graph event log is constructed based on the set of parent events of the event.

[0007] As a preferred embodiment of the learning-based disturbed observation constraint optimization method for final arbitration described in this invention, the method includes: publishing phased events through the final arbitration node. One or more final arbitration nodes are set up. The final arbitration nodes issue phased events according to a preset triggering strategy and collect reports from each participating node within the convergence window. The node-local frontier event sets in the report are merged into a candidate set, the number of times each event is observed is counted, and the stage boundary frontier of the staged events is calculated.

[0008] As a preferred embodiment of the learning-based disturbed observation constraint optimization method with final arbitration as described in this invention, wherein: each participating node generates a deterministic execution sequence based on the phased events, including: Each participating node defines an ancestor closure and calculates the covering set based on the published phased events; For the set of locally known events in the event log, calculate the pending phases, and execute the events in the pending phases only after all the corresponding events of the published phases have been executed; Events within the same period are sorted according to event type priority, causal topological order, and event identifier determinism to generate the execution order within the period.

[0009] As a preferred embodiment of the learning-based perturbed observation constraint optimization method with final arbitration as described in this invention, the method includes: executing an iterative recovery algorithm on the perturbed data in the observation event, outputting the recovery result and the observation uncertainty index, and generating a recovery event and writing it into the event log, including: A measurement model containing nonlinear distortion and / or quantization is established for the observation data in the observed event, and iterative recovery is performed through the spectral prior of the target frequency band and the interference frequency band. Each iteration includes at least one of nonlinear denoising, spectral prior denoising, and message update. Based on the iterative recovery, the recovery results and observation uncertainty indicators are output, and a recovery event is generated and written to the event log.

[0010] As a preferred embodiment of the learning-based disturbed observation constraint optimization method for final arbitration described in this invention, the method includes: constructing a continuous weight mapping function, integrating the weights into the original function to transform it into a robust corresponding function, comprising: Based on the aforementioned observation uncertainty index Construct a continuous weight mapping function And based on the weights, the true objective function With the actual constraint function Convert to robust objective function With robust constraint function ; Wherein, the robust objective function By the true objective function Superposition and continuous weight mapping function The relevant penalty terms are constructed, and the robust constraint function is defined. By using the actual constraint function Superposition and continuous weight mapping function The relevant safety margin terms are constructed, and the robust objective function is defined. With robust constraint function With continuous weight mapping function Continuous change.

[0011] As a preferred embodiment of the learning-based disturbed observation constraint optimization method with final arbitration as described in this invention, the method includes: maintaining a pool of surrogate models for approximating the robust corresponding function, and generating candidate solutions using a two-stage process, including: Maintain the pool of proxy models, where each model is used to approximate the robust objective function and the robust constraint function; In each iteration, a two-stage optimization is performed based on the selected surrogate model. The first stage prioritizes reducing constraint violations to obtain feasible improvements, and the second stage improves the surrogate objective while satisfying the surrogate constraints to generate candidate solutions. The first stage aims to minimize the total number of constraint violations, while the second stage aims to minimize the surrogate objective under the condition that the surrogate constraints are satisfied, and performs parameter boundary pruning on the candidate solutions.

[0012] Secondly, the present invention provides a learning-based disturbed observation constraint optimization system with final arbitration, comprising: The event log module is used to encapsulate optimization operations in a distributed system into events and build a hash-directed acyclic graph event log. The execution sequence generation module is used to set a final arbitration node based on the hash directed acyclic graph event log, publish phased events through the final arbitration node, and generate a deterministic execution sequence based on the phased events of each participating node; The iterative recovery module is used to execute an iterative recovery algorithm on the disturbed data in the observed event, output the recovery results and the observation uncertainty index, and generate a recovery event to write to the event log; The optimization control module is used to construct a continuous weight mapping function based on the observation uncertainty index, integrate the weights into the original function to convert it into a robust corresponding function, maintain a surrogate model pool for approximating the robust corresponding function, and generate candidate solutions using a two-stage process. The parameter activation module is used to generate a parameter submission activation event and write it to the event log when the candidate solution satisfies the true robustness constraint and improves the true robustness objective. The execution node applies the parameter update under the phased event containing the submission activation event and the corresponding boundary of its phased boundary front.

[0013] Thirdly, the present invention provides a computer device, comprising: Memory and processor; The memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions, which, when executed by the processor, implement the steps of the learning-based disturbed observation constraint optimization method with finality arbitration.

[0014] Fourthly, the present invention provides a computer-readable storage medium storing computer-executable instructions that, when executed by a processor, implement the steps of the learning-based disturbed observation constraint optimization method with finality arbitration.

[0015] Compared with existing technologies, the beneficial effects of this invention are as follows: This invention publishes Epoch and Frontier through a final arbitration node, ensuring that each node still generates a consistent execution sequence under concurrent, out-of-order, and partitioned conditions, preventing the optimization trajectory from being contaminated by rollback; by iteratively restoring the output recovery results and uncertainties, it reduces false feasibility / false improvements, lowers oscillations, and improves constraint satisfaction stability; by combining a proxy pool with two-stage feasibility priority and normalized rewards for phased stability and uncertainty indicators coupled with mode selection, it reduces the number of real evaluations and increases the feasibility improvement rate under the same budget, while reducing the risk of the strategy being contaminated by noise and concurrency. Attached Figure Description

[0016] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1 This is a schematic diagram of the overall process of a learning-based disturbed observation constraint optimization method with final arbitration according to an embodiment of the present invention.

[0018] Figure 2 This is a schematic diagram of the overall architecture of a learning-based disturbed observation constraint optimization method with final arbitration according to an embodiment of the present invention.

[0019] Figure 3 This is a schematic diagram of the phased arbitration and coverage determination and reinforcement learning model selection structure of a final arbitration learning-based disturbed observation constraint optimization method according to an embodiment of the present invention. Detailed Implementation

[0020] To make the above-mentioned objects, features, and advantages of the present invention more apparent and understandable, specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the protection scope of the present invention.

[0021] Reference Figures 1-3 As an embodiment of the present invention, a learning-based disturbed observation constraint optimization method with final arbitration is provided, comprising: S100 encapsulates optimization operations in a distributed system as events and constructs a hash-directed acyclic graph event log. S200, based on hash-directed acyclic graph event logs, sets up a final arbitration node, publishes phased events through the final arbitration node, and each participating node generates a deterministic execution sequence based on the phased events; S300 performs an iterative recovery algorithm on the disturbed data in the observed event, outputs the recovery result and the observation uncertainty index, and generates a recovery event to write to the event log; S400 constructs a continuous weight mapping function based on the observation uncertainty index, integrates the weights into the original function to transform it into a robust corresponding function, maintains a surrogate model pool for approximating the robust corresponding function, and generates candidate solutions using a two-stage process. S500: When a candidate solution satisfies the true robustness constraint and improves the true robustness objective, a parameter submission effective event is generated and written to the event log. The execution node applies the updated parameters under the phased event containing the submission effective event and the corresponding boundary of its phased boundary front.

[0022] Preferably, optimization operations in a distributed system are encapsulated as events, and a hash-directed acyclic graph event log is constructed, including: Encapsulate operations related to observation, recovery, evaluation, candidate generation, parameter submission and activation, and rollback in a distributed system as events; An event must include at least an event identifier, a parent event set, an event type, and a payload summary; When a new event occurs, a hashed directed acyclic graph event log is constructed based on the event's parent event set.

[0023] Specifically, all optimization-related operations within the system will be uniformly encapsulated into event e, which will contain at least the following fields: The event identifier eid is represented as eid=Hash(type||payload_hash||parents||creator||nonce); The parent event identifier set `parents[]` is used to represent causal predecessors; Event type, including at least: Observation Reporting (OBS), Recovery Output (REC), Reality Evaluation (EVAL), Agent Update (MODEL_UPD), Candidate Generation (CAND), Commit to Take Effect (COMMIT), Reversal / Rollback (REVOKE), and Constraint Set Switching (CONS). SW ; The payload summary hash, payload_hash, is a summary of parameter vectors / observation blocks / model weights, etc. The event may also include the external storage address (payload_uri), signature (sig), and local time (local). time In addition, summary metrics such as NMSE, observation uncertainty index u, and throughput.

[0024] A hash-based directed acyclic graph (DAG) event log is constructed. When event e occurs, its parents[] are set to point to its causal predecessor event, so that the event set forms a DAG under the parent relationship. That is, if the parents of event e contain p, then there exists an edge p→e, forming an acyclic directed structure. The payload can be stored externally, and only the digest and index are stored in the event to improve throughput. The system allows message out-of-order delivery and latency jitter, and does not require global clock consistency; causal relationships are only constrained by parents.

[0025] Preferably, the phased events are published through the final arbitration node, including: Set up one or more final arbitration nodes. The final arbitration nodes issue phased events according to the preset triggering strategy and collect reports from each participating node within the convergence window. The local frontier event sets of the nodes in the report are merged into a candidate set, the number of times each event is observed is counted, and the stage boundary frontier of the staged events is calculated.

[0026] In this embodiment, at least an observation node, a recovery node, an optimization control node, a finality arbitration node, and an execution node are included. The observation node is used to collect observations and generate OBS events; the recovery node is used to perform iterative recovery, outputting recovery results and observation uncertainty indicators, and generating REC events; the optimization control node is used to construct robust objectives / constraints, maintain a proxy pool, generate candidates in two phases, perform dynamic model selection using RL, and generate EVAL / CAND / COMMIT events; the finality arbitration node is used to converge reports and publish Epochs and Frontiers; and the execution node is used to apply COMMIT only at the corresponding Epoch boundaries and execute REVOKE when necessary.

[0027] Specifically, the final arbitration node publishes the phased event Epoch(k), which contains at least the incrementing epoch number. id =k, the frontier set of events at the stage boundary frontier[]=Frontier(k); may also include the arbitration threshold quorum=q, and the convergence window summary window. info , signature sig F .

[0028] Furthermore, the final arbitration node generates a new phase using any of the following triggering methods: Periodic triggering, triggered every ΔT seconds or accumulated N events, wherein ΔT is preferably 0.5 to 10 seconds and N is preferably 50 to 500; On-demand triggering (mandatory) immediately triggers a new phase in response to non-monotonic sensitive events. Sensitive events include at least parameter undo / rollback (REVOKE) and constraint set switching (CONS). SW It can also include permission downgrade events.

[0029] In this embodiment, each participating node periodically or on demand reports R. i It must include at least: The local frontier event set is the tip set `tips[]`, and the latest confirmed epoch number of the node is `last_epoch`. id It can also include digest verification and signature sig. i The tip set is defined as a collection of locally known events that are not referenced by any event as their parent.

[0030] Furthermore, the final arbitration node collects reports within window W, and the window closing condition can be any of the following conditions being met: Continuous ΔT F The preferred time is 0.5 to 10 seconds; At least Q reports are collected, where Q can be any of the majority thresholds; Responding to REVOKE / CONS SW For non-monotonous sensitive events, immediately close the window and proceed with the generation process.

[0031] Furthermore, an arbitration threshold q is set, preferably a majority threshold. The arbitration node forms a candidate union of all tips within the window. And the observed count of the events was performed. count(e) This can be accumulated by traversing the ancestor closures of each tip.

[0032] Define qualified set : ; Let the frontier of the period boundary be the largest set of elements in Eligible, which has no successor in Eligible, represented as: ; The final release of the phase event Epoch(k) carries the phase boundary frontier Frontier(k) = Frontier.

[0033] Preferably, the deterministic execution sequence generated by each participating node based on the phased events includes: Each participating node defines an ancestor closure and calculates the covering set based on the published phased events; For the set of locally known events in the event log, calculate the pending phases, and execute the events in the pending phases only after all the corresponding events of the published phases have been executed; Events within the same period are sorted according to event type priority, causal topological order, and event identifier determinism to generate the execution order within the period.

[0034] Specifically, the ancestor closure Anc(e) of event e (including itself) is defined as follows: ; The set of coverage for each period Epoch(k) is defined as: ; The cumulative coverage set of published epochs (1..K) is represented as follows: ; The node's local known event set is The set of phases to be processed is defined as follows: ; Furthermore, for any given time period, the published Epoch(1..K): Nodes are only allowed to execute Internal events, and shall be executed in the order of the phases described below; right Even if an event's parents reference an event that has already been published, it must not be inserted into the execution sequence of a published phase for premature execution. Instead, it must wait for a subsequent new phase to be published so that it can enter the execution sequence. Execution is only allowed after all other events in the Pending phase are completed. Even if an event in the Pending phase has a causal predecessor that is within the published phase, it will not be executed in the order of the published phases. Instead, it will be executed uniformly after all published phases are completed.

[0035] Furthermore, the deterministic ordering rule within a phase means that events within the same phase are ordered from high to low using a three-level sorting method. Each event is executed sequentially according to the sorted order, outputting a deterministic event execution sequence. All nodes execute the exact same operation order under the same phase boundary. The specific sorting priority is as follows: Event type priority type priority The event type priority should include at least the following: Revoke events take precedence over constraint switching events, constraint switching events take precedence over parameter submission and effect events, and parameter submission and effect events take precedence over evaluation and recovery events. In other words, the preferred order is: REVOKE > CONS SW >COMMIT>EVAL>REC>OBS; Causal topological order (topo) order The order is based on the topological order of parents to ensure that the causal predecessor is executed first. Event identifier eid lex The events are sorted lexicographically by their identifiers to break ties and ensure certainty.

[0036] Preferably, for the perturbed data in the observed event, an iterative recovery algorithm is executed, the recovery result and the observation uncertainty index are output, and a recovery event is generated and written to the event log, including: A measurement model containing nonlinear distortion and / or quantization is established for the observation data in the observed event, and iterative recovery is performed through the spectral prior of the target frequency band and the interference frequency band. Each iteration includes at least one of nonlinear denoising, spectral prior denoising, and message update. Based on iterative recovery, the system outputs the recovery results and observation uncertainty indicators, and generates recovery events which are written to the event log.

[0037] Specifically, the observation can be represented as: ; in, For quantization operators, the bit width is preferably 1 to 12 bits. For nonlinear front-ends, soft saturation types are preferred, such as tanh(x) / x or equivalent transformations. It is noise.

[0038] Simultaneously utilizing spectrum priors, the target frequency band set With interference frequency band set Non-overlapping or nearly non-overlapping, based on which a frequency band mask is constructed. .

[0039] Furthermore, let the number of iteration rounds be... Preferably 5 to 20, initialize state variables, such as residuals / estimation vectors, and accuracy parameters. .right Perform the following steps: Perform a nonlinear denoising sub-step (NN-Denoise), specifically, inputting the previous round's state, accuracy parameters, and observations. The input is normalized and then fed into the neural network. Output denoising results With update coefficient The neural network has a preferred hidden width of 32 to 256, and can be trained offline with optional online fine-tuning.

[0040] The Spec-Denoise sub-step is performed, which preserves and suppresses frequency domain variables by using target and interference band masks, and uses leakage preservation coefficients. Adjust the interference frequency band leakage. Specifically, Transform to the frequency domain to obtain Updated by mask, represented as: ; in, The leakage retention coefficient is preferably 0–0.3 for strong suppression and 0.3–1 for weak suppression; the inverse transformation yields… .

[0041] The message update sub-step (Msg-Update) is executed. Specifically, the status and precision parameters are updated according to the update coefficient and residual, as shown below: ; ; in, Indicates the first The state variables after the round message update, Indicates the first The current estimated value after denoising processing. Indicates the first The estimated value of the wheel, This represents the momentum update coefficient, used to control the difference in estimates between two adjacent rounds. The strength of the impact on the update of the current state variable, in order to improve the convergence speed while suppressing iterative oscillations; Indicates the first The updated accuracy parameters This represents the precision adjustment amount obtained based on the current round residual statistics; This represents the limiting function, used to limit the input value. Cut off in interval Inside; This indicates the lower limit of the accuracy parameter, used to prevent excessively small accuracy parameters from causing update stagnation, numerical instability, or decreased recovery capability. Preferably, it represents the lower limit of the accuracy parameter. ; This represents the upper limit of the precision parameter, used to prevent excessively large precision parameters from causing residual disturbances to be over-amplified, updates to be too aggressive, or iterations to diverge. Preferably, it represents the upper limit of the precision parameter. .

[0042] Furthermore, the recovery result is output upon completion of the recovery process. Such as target frequency band sub-vectors, and uncertainty indicators Observation of uncertainty indicators It is calculated from the iterative residual energy, the monotonic function of the equivalent accuracy parameter, or the reconstruction error, as follows: Uncertainty index based on residual energy calculation : ; Construct an uncertainty index based on the final accuracy parameter , represented as: ; in, Indicates the iteration number corresponding to the termination of the iteration; To prevent zero constants, used to avoid numerical instability caused by a denominator that is zero or too small; Indicates the first The final accuracy parameter obtained at the end of the iteration is used to characterize the degree of certainty of the current state estimation result. The larger the value, the more stable and reliable the estimation result, and the lower the corresponding uncertainty. This uncertainty index, constructed based on the reciprocal of the final accuracy parameter, is used to quantify the volatility risk of the current estimation result. Since the accuracy parameter is positively correlated with the confidence level of the estimation result, its reciprocal form is used to characterize the uncertainty. Based on this uncertainty index... The reliability of the current estimation result is determined, and the determination result is recorded as an event and written to the event log.

[0043] Preferably, a continuous weight mapping function is constructed, and the weights are incorporated into the original function to transform it into a robust corresponding function, including: Based on observation uncertainty index Construct a continuous weight mapping function And based on the weights, the true objective function With the actual constraint function Convert to robust objective function With robust constraint function ; Among them, the robust objective function By using the real objective function Superposition and continuous weight mapping function Construct relevant penalty terms and robust constraint functions. By using the actual constraint function Superposition and continuous weight mapping function Construct relevant safety margin terms and robust objective function. With robust constraint function With continuous weight mapping function Continuous change.

[0044] Specifically, continuous weight mapping function Represented as: ; in, For smoothing the scaling parameters, the most recent L times are preferred. The median or mean is on the same order of magnitude, and L is preferably 5 to 50.

[0045] Furthermore, the parameter vector to be optimized , express 3D real space, boundary The true objective function True constraint function , represented as: ; ; in: For risk penalties, options include switching frequency penalties, power consumption fluctuation penalties, and step size risk penalties; The penalty increases as the distance from the saturation boundary increases, serving as a safety margin function. These are the weighting coefficients.

[0046] Preferably, a pool of surrogate models is maintained for approximating robust corresponding functions, and a two-stage process is used to generate candidate solutions, including: Maintain a pool of proxy models, each model used to approximate a robust objective function and a robust constraint function; In each iteration, a two-stage optimization is performed based on the selected surrogate model. The first stage prioritizes reducing constraint violations to obtain feasible improvements, and the second stage improves the surrogate objective while satisfying the surrogate constraints to generate candidate solutions. The first stage aims to minimize the total number of constraint violations, while the second stage aims to minimize the surrogate objective under the condition that the surrogate constraints are satisfied, and performs parameter boundary pruning on the candidate solutions.

[0047] Specifically, maintain the proxy model pool. K is preferably 5-30, and each proxy model is paired with... and Establish approximation and .

[0048] Agent training dataset : ; Data is accumulated from EVAL events.

[0049] In each iteration, the selected agent model The following two phases will be executed: Phase I, feasibility recovery, aims to minimize the total number of constraint violations: ; in, To constrain violations of the total amount.

[0050] Phase II, improvement within the feasible region, aims to minimize the proxy objective while satisfying the proxy constraints: ; Then, boundary pruning is performed on the candidates to generate candidate solutions. : ; Optionally, set the maintenance trust domain radius. As the error between the actual assessment and the proxy prediction increases, the value is continuously reduced. If the error remains stable, it will continuously increase. This is to reduce the risk of crossing feasible domains due to proxy errors.

[0051] Furthermore, the surrogate model selection is modeled as a Markov decision process, where the state includes at least the global optimization feature, the statistical feature of observation uncertainty, and the periodic stability feature, and the action corresponds to selecting a surrogate model from the surrogate model pool; a reward function is constructed based on the feasibility and improvement principle and combined with the observation uncertainty index u, and a reinforcement learning strategy is used to select the surrogate model for the current iteration.

[0052] The phased stability characteristics include at least the proportion of recent parameter submissions that were covered by revocation events and the statistics of the phased event release interval. The reward function, under the condition of satisfying robust constraints and robust objective improvement, is based on the robust objective improvement amount and... The ratio is normalized to reduce the misleading effect of false improvements caused by observation uncertainty on reinforcement learning strategies.

[0053] Specifically, we define a Markov Decision Process (MDP), where the state... It should include at least three types of feature concatenation: global optimization features, uncertainty statistics features or periodic stability features, and optional surrogate model fitting quality features. Global optimization features could include budget percentage, recent improvement statistics, feasibility rate, etc., while uncertainty statistics could include the most recent L times... mean / variance The mean and periodic stability features must include at least the withdrawal coverage rate. With period interval variance The fitting quality characteristics of the surrogate model include residuals and crossover errors.

[0054] action To select one from K proxy models The action space guiding the current iteration is {1..K}; Strategies can be adopted ε-greedy , The preferred exploration strategy is 0.01 to 0.2 or equivalent.

[0055] Furthermore, the periodic stability characteristics are calculated as follows: Within the sliding window length L, select the L nearest COMMIT event sets. Define a revocation coverage indicator: if a REVOKE occurs that causes the COMMIT to fall into the corresponding phased coverage set, record it as 1; otherwise, record it as 0; revocation coverage rate. Represented as: ; in, This indicates the number of parameter submissions that took effect within the sliding window that were included in the statistics; Indicates the first [number] within the sliding window Each parameter is submitted and the event takes effect; Indicates the first Parameter submission effective event The undo override instruction function, when an undo event REVOKE occurs, causes the parameter to submit an effective event. When it falls into the corresponding phased coverage set, ,otherwise, ; This indicates the proportion of parameter submission effective events within the sliding window that are overridden by revocation, and is used to characterize the current stage stability.

[0056] Let {t} be the arrival timestamps of the most recent M epochs, and let the variance of the intervals be... From the interval sequence Calculation, the above , An equivalent transformation must be performed by entering the state vector.

[0057] Furthermore, the reward function employs a two-stage reward system, including: Feasibility gating, if candidate Not all robust constraints are satisfied ,but .

[0058] When feasibility is satisfied, define the normalized improvement amount: ; in, To prevent zero constant, the preferred method is... The reward is: ; in, For compression mapping, it can be sigmoid or piecewise linear, ensuring that the reward is bounded.

[0059] Optionally, the reward can be multiplied by the installment stability weight, for example... This is to prevent the strategy from being contaminated when the staging is unstable.

[0060] Maintain the experience replay pool From each round or every H round The parameters of the value network can be updated in small batches by sampling, and the target network can be slowed down to enhance stability.

[0061] Specifically, in step S500, the commit and revoke actions are performed at the phase boundary when the actual evaluation results meet the following conditions: and (Or, by minimizing consistent comparisons), COMMIT(x) is generated. {new}The event is written to the DAG, and the final arbiter node is requested to publish the Epoch(k) containing the COMMIT. The execution node only applies parameter updates after receiving the Epoch boundary containing the COMMIT, thereby achieving distributed consistency and suppressing rollback. When a reversal / rollback requirement occurs, a REVOKE event is generated and the reversal order is solidified by the required Epoch, ensuring consistent rollback across the entire network.

[0062] Furthermore, missing event completion and consistency checks are performed. When a node receives Epoch(k), if it is missing the minimum necessary fields (eid, parents, type, payload_hash) of an event or its ancestor in Frontier(k), it will complete the missing event through the payload. uri Alternatively, the index service can retrieve and supplement the data as needed; after supplementation, Anc, Covered, and Pending are calculated and the topological order is executed. If a cycle or illegal reference is found, execution is rejected and the data is reported to the arbitration node for policy processing.

[0063] It should be noted that this invention publishes Epoch and Frontier through a finality arbitration node, defines Covered by ancestor closure and classifies uncovered events into Pending and executes them later. At the same time, within the phase, events are deterministically sorted by type priority, topological order, and event identifier. Under concurrency, out-of-order, and partitioning, each node still generates a consistent execution sequence. Unfinalized events are not executed in advance, non-monotonic sensitive update order is fixed, optimization trajectory is not polluted by rollback, and parameter effectiveness is reproducible and auditable.

[0064] This invention iteratively recovers the output recovery results and uncertainties, and continuously constructs robust objectives / constraints. It automatically conserves when observations are unstable and automatically pursues performance when observations are stable, thereby reducing false feasibility / false improvements, reducing oscillations, and improving constraint satisfaction stability.

[0065] This invention combines a proxy pool with a two-stage feasibility priority and a normalized reward that couples phased stability and uncertainty indicators in the model selection process. In unstable phases or with high uncertainty, it naturally reduces the returns of aggressive exploration and favors robust proxies. Under the same budget, it reduces the number of real evaluations and increases the feasible improvement rate, while reducing the risk of the strategy being contaminated by noise and concurrency.

[0066] The above is an illustrative scheme of a final arbitration-based learning-based disturbed observation constraint optimization method according to this embodiment. It should be noted that the technical solution of this final arbitration-based learning-based disturbed observation constraint optimization system belongs to the same concept as the technical solution of the aforementioned final arbitration-based learning-based disturbed observation constraint optimization method. Details not described in detail in the technical solution of the final arbitration-based learning-based disturbed observation constraint optimization system in this embodiment can be found in the description of the technical solution of the aforementioned final arbitration-based learning-based disturbed observation constraint optimization method.

[0067] This embodiment provides a learning-based disturbed observation constraint optimization system with final arbitration, including: The event log module is used to encapsulate optimization operations in a distributed system into events and build a hash-directed acyclic graph event log. The execution sequence generation module is used to set up a final arbitration node based on the hash-directed acyclic graph event log, publish phased events through the final arbitration node, and generate a deterministic execution sequence based on the phased events. The iterative recovery module is used to execute an iterative recovery algorithm on the disturbed data in the observed event, output the recovery results and the observation uncertainty index, and generate a recovery event to write to the event log; The optimization control module is used to construct a continuous weight mapping function based on the observation uncertainty index, integrate the weights into the original function to convert it into a robust corresponding function, maintain a surrogate model pool for approximating the robust corresponding function, and generate candidate solutions using a two-stage process. The parameter activation module is used to generate a parameter submission activation event and write it to the event log when a candidate solution satisfies the true robustness constraint and improves the true robustness objective. The execution node then applies the parameter update under the phased event containing the submission activation event and the corresponding boundary of its phased boundary front.

[0068] This embodiment also provides a computer device suitable for learning-based disturbed observation constraint optimization with final arbitration, including: The system includes a memory and a processor. The memory stores computer-executable instructions, and the processor executes the computer-executable instructions to implement a learning-based disturbed observation constraint optimization method with final arbitration as proposed in the above embodiments.

[0069] This embodiment also provides a storage medium storing a computer program that, when executed by a processor, implements a learning-based disturbed observation constraint optimization method with final arbitration as proposed in the above embodiments.

[0070] The storage medium proposed in this embodiment belongs to the same inventive concept as the learning-based disturbed observation constraint optimization method for implementing a final arbitration proposed in the above embodiments. Technical details not described in detail in this embodiment can be found in the above embodiments, and this embodiment has the same beneficial effects as the above embodiments.

[0071] Based on the above description of the implementation methods, those skilled in the art can clearly understand that the present invention can be implemented using software and necessary general-purpose hardware, and of course, it can also be implemented using hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as a computer floppy disk, read-only memory (ROM), random access memory (RAM), flash memory, hard disk, or optical disk, etc., including several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods of the various embodiments of the present invention.

[0072] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not 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 or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A learning-based perturbed observation constraint optimization method with final arbitration, characterized in that, include: Encapsulate optimization operations in distributed systems as events and construct a hash-directed acyclic graph event log; Based on the hash-directed acyclic graph event log, a final arbitration node is set up, and phased events are published through the final arbitration node. Each participating node generates a deterministic execution sequence based on the phased events. For the disturbed data in the observed events, an iterative recovery algorithm is executed, the recovery results and observation uncertainty indicators are output, and the recovery events are generated and written to the event log; Based on the observation uncertainty index, a continuous weight mapping function is constructed, the weights are integrated into the original function to transform it into a robust corresponding function, a surrogate model pool is maintained to approximate the robust corresponding function, and a two-stage process is used to generate candidate solutions. When the candidate solution satisfies the true robustness constraint and improves the true robustness objective, a parameter submission effective event is generated and written to the event log, and the execution node applies the updated parameters under the phased event containing the submission effective event and the corresponding boundary of its phased boundary front.

2. The learning-based disturbed observation constraint optimization method with final arbitration as described in claim 1, characterized in that, Encapsulating optimization operations in a distributed system as events and constructing a hash-directed acyclic graph event log includes: Encapsulate operations related to observation, recovery, evaluation, candidate generation, parameter submission and activation, and rollback in a distributed system as events; The event shall include at least an event identifier, a parent event set, an event type, and a payload summary; When a new event occurs, a hashed directed acyclic graph event log is constructed based on the set of parent events of the event.

3. The learning-based disturbed observation constraint optimization method with final arbitration as described in claim 1, characterized in that, The release of phased events through the aforementioned final arbitration node includes: One or more final arbitration nodes are set up. The final arbitration nodes issue phased events according to a preset triggering strategy and collect reports from each participating node within the convergence window. The node-local frontier event sets in the report are merged into a candidate set, the number of times each event is observed is counted, and the stage boundary frontier of the staged events is calculated.

4. The learning-based disturbed observation constraint optimization method with final arbitration as described in claim 3, characterized in that, Each participating node generates a deterministic execution sequence based on the phased events, including: Each participating node defines an ancestor closure and calculates the covering set based on the published phased events; For the set of locally known events in the event log, calculate the pending phases, and execute the events in the pending phases only after all the corresponding events of the published phases have been executed; Events within the same period are sorted according to event type priority, causal topological order, and event identifier determinism to generate the execution order within the period.

5. The learning-based disturbed observation constraint optimization method with final arbitration as described in claim 4, characterized in that, For the perturbed data in the observed event, an iterative recovery algorithm is executed, the recovery result and the observation uncertainty index are output, and the recovered event is generated and written to the event log, including: A measurement model containing nonlinear distortion and / or quantization is established for the observation data in the observed event, and iterative recovery is performed through the spectral prior of the target frequency band and the interference frequency band. Each iteration includes at least one of nonlinear denoising, spectral prior denoising, and message update. Based on the iterative recovery, the recovery results and observation uncertainty indicators are output, and a recovery event is generated and written to the event log.

6. The learning-based disturbed observation constraint optimization method with final arbitration as described in claim 5, characterized in that, Construct a continuous weight mapping function, integrate the weights into the original function to transform it into a robust corresponding function, including: Based on the aforementioned observation uncertainty index Construct a continuous weight mapping function And based on the weights, the true objective function With the actual constraint function Convert to robust objective function With robust constraint function ; Wherein, the robust objective function By the true objective function Superposition and continuous weight mapping function The relevant penalty terms are constructed, and the robust constraint function is defined. By using the actual constraint function Superposition and continuous weight mapping function The relevant safety margin terms are constructed, and the robust objective function is defined. With robust constraint function With continuous weight mapping function Continuous change.

7. The learning-based disturbed observation constraint optimization method with final arbitration as described in claim 6, characterized in that, Maintain a pool of surrogate models for approximating the robust corresponding function, and generate candidate solutions using a two-stage process, including: Maintain the pool of proxy models, where each model is used to approximate the robust objective function and the robust constraint function; In each iteration, a two-stage optimization is performed based on the selected surrogate model. The first stage prioritizes reducing constraint violations to obtain feasible improvements, and the second stage improves the surrogate objective while satisfying the surrogate constraints to generate candidate solutions. The first stage aims to minimize the total number of constraint violations, while the second stage aims to minimize the surrogate objective under the condition that the surrogate constraints are satisfied, and performs parameter boundary pruning on the candidate solutions.

8. A learning-based disturbed observation constraint optimization system with final arbitration, employing the learning-based disturbed observation constraint optimization method with final arbitration as described in any one of claims 1 to 7, characterized in that, include: The event log module is used to encapsulate optimization operations in a distributed system into events and build a hash-directed acyclic graph event log. The execution sequence generation module is used to set a final arbitration node based on the hash directed acyclic graph event log, publish phased events through the final arbitration node, and generate a deterministic execution sequence based on the phased events of each participating node; The iterative recovery module is used to execute an iterative recovery algorithm on the disturbed data in the observed event, output the recovery results and the observation uncertainty index, and generate a recovery event to write to the event log; The optimization control module is used to construct a continuous weight mapping function based on the observation uncertainty index, integrate the weights into the original function to convert it into a robust corresponding function, maintain a surrogate model pool for approximating the robust corresponding function, and generate candidate solutions using a two-stage process. The parameter activation module is used to generate a parameter submission activation event and write it to the event log when the candidate solution satisfies the true robustness constraint and improves the true robustness objective. The execution node applies the parameter update under the phased event containing the submission activation event and the corresponding boundary of its phased boundary front.

9. A computer device, characterized in that, include: Memory and processor; The memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions, which, when executed by the processor, implement the steps of the learning-based disturbed observation constraint optimization method with final arbitration as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, It stores computer-executable instructions that, when executed by a processor, implement the steps of a learning-based disturbed observation constraint optimization method with final arbitration as described in any one of claims 1 to 7.

Images