Multi-entry intent cooperative control method and device, equipment and storage medium

Abstract

The present application relates to the technical field of electric digital data processing, and discloses a multi-entry intention collaborative control method, device, equipment and storage medium, which are used for the accuracy of multi-entry collaborative control.The multi-entry intention collaborative control method comprises the following steps: obtaining intention instructions from multiple control entries, and constructing an intention dependency graph; based on a preset unified state machine model, simulating execution according to the intention instructions and the intention dependency graph, so as to detect and identify conflict intentions, and obtain a conflict intention set; arbitrating the conflict intention set based on a reinforcement learning dynamic arbitration strategy, so as to obtain a winning intention instruction sequence; updating the global state of the unified state machine model according to the winning intention instruction sequence, and generating a global state snapshot; and publishing the global state snapshot to all control entries through an edge collaborative network, so as to realize state synchronization.

Description

Technical Field

[0001] This invention relates to the field of electronic digital data processing technology, and in particular to a multi-entry intentional collaborative control method, apparatus, device, and storage medium. Background Technology

[0002] With the widespread adoption of smart audio devices, multi-entry control has become mainstream. Existing solutions generally employ entry-side state caching and asynchronous synchronization mechanisms, making it difficult to maintain consistency across entry points. Especially during concurrent operations, network latency, or the intervention of automatic policies, the system is prone to issues such as state conflicts, display rollbacks, and uncertain final behavior, directly impacting the accuracy of control and the overall reliability of the system. Summary of the Invention

[0003] This invention provides a multi-entry intent collaborative control method, apparatus, device, and storage medium to solve the problems in the prior art that rely on entry-side state caching and asynchronous synchronization mechanisms, which easily lead to state conflicts, display rollbacks, and uncertain final behavior in the system.

[0004] The first aspect of this invention provides a multi-entry intention collaborative control method, comprising: acquiring intention instructions from multiple control entry points and constructing an intention dependency graph; performing simulated execution based on a preset unified state machine model according to the intention instructions and the intention dependency graph to detect and identify conflicting intentions, thereby obtaining a set of conflicting intentions; adjudicating the set of conflicting intentions based on a reinforcement learning dynamic arbitration strategy to obtain a winning intention instruction sequence; updating the global state of the unified state machine model according to the winning intention instruction sequence and generating a global state snapshot; and publishing the global state snapshot to all control entry points through an edge collaborative network to achieve state synchronization.

[0005] In one feasible implementation, the step of acquiring intent instructions from multiple control entry points and constructing an intent dependency graph includes: receiving intent instructions from multiple control entry points, extracting the target state field, operation type, and operation parameters operated by each intent instruction, and generating standardized intent description objects; analyzing the semantic relationships between the standardized intent description objects, identifying explicit dependencies between intent instructions at the state read and write levels, as well as implicit dependencies based on preset business rules and state field mapping relationships; and constructing an intent dependency graph that reflects the operation order and causal logic among all intent instructions by using each intent instruction as a node and the identified explicit and implicit dependencies as directed edges.

[0006] In one feasible implementation, the step of extracting the target state field, operation type, and operation parameters operated by each intent instruction and generating a standardized intent description object includes: performing syntactic parsing on the received original intent instruction to identify verbs, objects, and modifiers, and mapping them to operation type, target state field, and operation parameters, respectively; filling the operation type, target state field, and operation parameters into a structured data template according to a predefined pattern to form a primary intent object; and performing semantic disambiguation and unit standardization processing on the primary intent object to generate a standardized intent description object with unified semantics and measurement units.

[0007] In one feasible implementation, the step of analyzing the semantic relationships between the standardized intent description objects and identifying explicit dependencies between intent instructions at the state read and write levels, as well as implicit dependencies based on preset business rules and state field mapping relationships, includes: analyzing the data flow semantics between any two sets of target state fields operated by the standardized intent description objects, and identifying explicit dependencies caused by writing before reading or reading before writing the same field; and analyzing the business logic semantics between the operation targets and parameters by inputting the standardized intent description objects into a preset rule reasoning engine, and identifying implicit dependencies that logically have premise, causal, or deductive relationships based on a predefined business rule graph and state field mapping relationships.

[0008] In one feasible implementation, the step of constructing an intent dependency graph reflecting the operation order and causal logic among all intent instructions, using each intent instruction as a node and the identified explicit and implicit dependencies as directed edges, includes: creating a unique graph node with the standardized intent description object corresponding to each intent instruction as an attribute, forming a node set of the intent dependency graph; establishing directed edges with direction between the corresponding graph nodes according to the identified explicit and implicit dependencies, wherein the direction of the edges points from the source intent in the dependency relationship to the target intent, forming an edge set of the intent dependency graph; and generating a final directed graph structure based on the node set and edge set, which serves as the intent dependency graph, wherein the topological order of the intent dependency graph represents the theoretical execution order when there are no conflicts between intent instructions.

[0009] In one feasible implementation, the simulation execution to detect and identify conflicting intentions includes: According to a topological sorting sequence of the intent dependency graph, each intent instruction is sequentially simulated and executed on a simulation copy of the unified state machine model. During the simulation execution, concurrent write operations to the same state field are monitored. If the write value or operation logic is incompatible, the relevant intent instruction is marked as having a write-write conflict. During the simulation execution, the execution result of each intent instruction is verified according to preset state transition rules and business constraints. If any rule or constraint is violated, the corresponding intent instruction is marked as having a logical conflict.

[0010] In one feasible implementation, the step of sequentially simulating the execution of each intent instruction on a simulation copy of the unified state machine model according to a topological sorting sequence of the intent dependency graph includes: obtaining the adjacency list representation of the intent dependency graph; generating at least one topological sorting sequence using a depth-first or breadth-first search algorithm; selecting one of the topological sorting sequences as the current simulated instruction execution order; maintaining a virtual global state and instruction execution log in the simulation copy of the unified state machine model; and calling the state transition function corresponding to each intent instruction for simulated execution according to the selected sequence order.

[0011] In one feasible implementation, the monitoring of concurrent write operations to the same status field, if the write values ​​or operation logic are irreconcilable, marks the relevant intent commands as having a write-write conflict. This includes: recording the write operation and write value of each intent command to each status field in the simulation execution log; when it is detected that two or more intent commands have initiated write operations to the same status field within the same simulation execution cycle, triggering a write-write conflict check; comparing these write operations, if their write values ​​are definite and different from each other, or if the write functions they call are logically mutually exclusive, then they are determined to be irreconcilable, and all intent commands involving writing to that field are marked as having a write-write conflict.

[0012] In one feasible implementation, the step of verifying the execution result of each intent instruction according to preset state transition rules and business constraints, and marking the corresponding intent instruction as having a logical conflict if any rule or constraint is violated, includes: immediately capturing the intermediate state of the simulation copy after each intent instruction is simulated and executed; matching and verifying the intermediate state with all predefined state transition rules in the unified state machine model to check if any rule is violated; logically determining the intermediate state with preloaded business constraints to check if it exceeds the constraint range; if any rule is violated or any constraint is exceeded, the execution result of the intent instruction is determined to be illegal and marked as a logical conflict.

[0013] In one feasible implementation, the step of adjudicating the conflict intent set based on a reinforcement learning dynamic arbitration strategy to obtain a winning intent instruction sequence includes: extracting the operation target, conflict type identifier, and associated state field value in the unified state machine model for each conflict intent in the conflict intent set, concatenating them with the system's performance index load vector to form an arbitration state vector; inputting the arbitration state vector into a pre-trained reinforcement learning arbitration model, which outputs an arbitration action vector based on its policy network, where each dimension of the arbitration action vector corresponds to an intent in the conflict intent set, and its value represents the adjudication operation for that intent, including execution, modification, delay, or rejection; and filtering and reconstructing the intents in the conflict intent set according to the arbitration action vector to obtain a winning intent instruction sequence.

[0014] In one feasible implementation, updating the state of the unified state machine according to the winning intention instruction and generating a global state snapshot includes: sequentially executing state transition operations in the unified state machine model based on the order and operation logic of the winning intention instruction sequence to complete the atomic update of the global state; calculating the cryptographic hash value of the state data as the state root based on the updated global state, and encapsulating the state root with the digest information, state version identifier, and timestamp information of the winning intention instruction sequence to form an original state snapshot; digitally signing the original state snapshot to generate a global state snapshot, wherein the digital signature is generated using the private key of the control center.

[0015] In one feasible implementation, the step of publishing the global state snapshot to all control entry points through an edge collaborative network to achieve state synchronization includes: encoding the global state snapshot into a bearer message of a preset network protocol and distributing it through the multicast or broadcast channel of the edge collaborative network; after receiving the bearer message, each control entry point extracts the global state snapshot from it and verifies the digital signature of the global state snapshot using a pre-stored control center public key; after the signature verification is successful, it parses the state version identifier in the global state snapshot and compares it with the previous state version identifier stored locally; if the state version identifier is updated, the snapshot is accepted, and the local state copy is verified and updated based on the state root in the global state snapshot to complete state synchronization; if the version is the same or older, the snapshot is discarded.

[0016] A second aspect of the present invention provides a multi-entry intention collaborative control device, comprising: a construction module for acquiring intention commands from multiple control entry points and constructing an intention dependency graph; an identification module for performing simulated execution based on a preset unified state machine model according to the intention commands and the intention dependency graph, to detect and identify conflicting intentions and obtain a set of conflicting intentions; an adjudication module for adjudicating the set of conflicting intentions based on a reinforcement learning dynamic arbitration strategy to obtain a winning intention command sequence; a generation module for updating the global state of the unified state machine model according to the winning intention command sequence and generating a global state snapshot; and a synchronization module for publishing the global state snapshot to all control entry points through an edge collaborative network to achieve state synchronization.

[0017] In one feasible implementation, the construction module includes: a generation unit, configured to receive intent instructions from multiple control entry points, extract the target state field, operation type, and operation parameters operated by each intent instruction, and generate standardized intent description objects; an identification unit, configured to analyze the semantic relationships between the standardized intent description objects, identify explicit dependencies between intent instructions at the state read and write levels, and implicit dependencies based on preset business rules and state field mapping relationships; and a construction unit, configured to construct an intent dependency graph that reflects the operation order and causal logic among all intent instructions, using each intent instruction as a node and the identified explicit and implicit dependencies as directed edges.

[0018] In one feasible implementation, the generation unit is specifically used to: perform syntactic parsing on the received original intent instruction, identify the verbs, objects, and modifiers therein, and map them to operation type, target state field, and operation parameters, respectively; fill the operation type, the target state field, and the operation parameters into a structured data template according to a predefined pattern to form a primary intent object; and perform semantic disambiguation and unit standardization processing on the primary intent object to generate a standardized intent description object with unified semantics and measurement units.

[0019] In one feasible implementation, the identification unit is specifically used to: analyze the data flow semantics between any two sets of target state fields operated by standardized intent description objects, and identify explicit dependencies caused by writing before reading or reading before writing the same field; and analyze the business logic semantics between the operation target and parameters by inputting the standardized intent description object into a preset rule reasoning engine, and identify implicit dependencies that logically have premise, causal, or deductive relationships based on a predefined business rule graph and state field mapping relationship.

[0020] In one feasible implementation, the construction unit is specifically used to: create a unique graph node with the standardized intent description object corresponding to each intent instruction as an attribute, forming a node set of the intent dependency graph; establish directed edges with direction between the corresponding graph nodes according to the identified explicit and implicit dependencies, wherein the direction of the edges points from the source intent in the dependency relationship to the target intent, forming an edge set of the intent dependency graph; and generate the final directed graph structure based on the node set and the edge set, as the intent dependency graph, wherein the topological order of the intent dependency graph represents the theoretical execution order when the intent instructions do not conflict.

[0021] In one feasible implementation, the identification module is specifically configured as follows: an execution unit, configured to sequentially simulate the execution of each intent instruction on a simulation copy of the unified state machine model according to a topological sorting sequence of the intent dependency graph; a first marking unit, configured to monitor concurrent write operations on the same state field during the simulation execution process, and mark the relevant intent instruction as having a write-write conflict if the write value or operation logic is incompatible; and a second marking unit, configured to verify the execution result of each intent instruction according to preset state transition rules and business constraints during the simulation execution process, and mark the corresponding intent instruction as having a logical conflict if any rule or constraint is violated.

[0022] In one feasible implementation, the execution unit is specifically used to: obtain the adjacency list representation of the intent dependency graph; generate at least one topological sorting sequence using a depth-first or breadth-first search algorithm; select one of the topological sorting sequences as the instruction order for the current simulation execution; maintain a virtual global state and instruction execution log in the simulation copy of the unified state machine model; and call the state transition function corresponding to each intent instruction for simulation execution according to the selected sequence order.

[0023] In one feasible implementation, the first marking unit is specifically used to: record the write operation and write value of each intention instruction to each status field in the simulation execution log; when it is detected that two or more intention instructions have initiated write operations to the same status field in the same simulation execution cycle, a write-write conflict check is triggered; if these write operations are compared and their write values ​​are definite and different from each other, or the write functions they call are logically mutually exclusive, they are determined to be irreconcilable, and a write-write conflict is marked between all intention instructions involving the writing of that field.

[0024] In one feasible implementation, the second marking unit is specifically used to: immediately capture the intermediate state of the simulation copy after each intent instruction is simulated and executed; match and verify the intermediate state with all predefined state transition rules in the unified state machine model to check whether there are any violated rules; logically determine the intermediate state with preloaded business constraints to check whether it exceeds the constraint range; if any rule is violated or any constraint is exceeded, the execution result of the intent instruction is determined to be illegal and marked as a logical conflict.

[0025] In one feasible implementation, the adjudication module is specifically used to: extract the operation target, conflict type identifier, and associated state field value in the unified state machine model for each conflict intent in the conflict intent set, and concatenate them with the system's performance index load vector to form an arbitration state vector; input the arbitration state vector into a pre-trained reinforcement learning arbitration model, which, based on its policy network, outputs an arbitration action vector, where each dimension of the arbitration action vector corresponds to an intent in the conflict intent set, and its value represents the adjudication operation for that intent, including execution, modification, delay, or rejection; and filter and reconstruct the intents in the conflict intent set according to the arbitration action vector to obtain a winning intent instruction sequence.

[0026] In one feasible implementation, the generation module is specifically used to: sequentially execute state transition operations in the unified state machine model based on the order and operation logic of the winning intention instruction sequence to complete the atomic update of the global state; calculate the cryptographic hash value of the state data as the state root based on the updated global state, and encapsulate the state root with the digest information, state version identifier, and timestamp information of the winning intention instruction sequence to form an original state snapshot; digitally sign the original state snapshot to generate a global state snapshot, wherein the digital signature is generated using the private key of the control center.

[0027] In one feasible implementation, the synchronization module is specifically used to: encode the global state snapshot into a bearer message of a preset network protocol, and distribute it through the multicast or broadcast channel of the edge collaborative network; after receiving the bearer message, each control entry point extracts the global state snapshot from it and verifies the digital signature of the global state snapshot using a pre-stored control center public key; after the signature verification is successful, it parses the state version identifier in the global state snapshot and compares it with the previous state version identifier stored locally; if the state version identifier is updated, the snapshot is accepted, and the local state copy is verified and updated based on the state root in the global state snapshot to complete state synchronization; if the version is the same or older, the snapshot is discarded.

[0028] A third aspect of the present invention provides an electronic device, comprising: a memory and at least one processor, wherein the memory stores instructions; the at least one processor invokes the instructions in the memory to cause the electronic device to execute the above-described multi-entry intention cooperative control method.

[0029] A fourth aspect of the present invention provides a computer-readable storage medium storing instructions that, when executed on a computer, cause the computer to perform the above-described multi-entry intent cooperative control method.

[0030] The technical solution provided by this invention involves acquiring intent commands from multiple control entry points and constructing an intent dependency graph; performing simulated execution based on a preset unified state machine model according to the intent commands and the intent dependency graph to detect and identify conflicting intents, thereby obtaining a set of conflicting intents; resolving the set of conflicting intents based on a reinforcement learning dynamic arbitration strategy to obtain a winning intent command sequence; updating the global state of the unified state machine model according to the winning intent command sequence and generating a global state snapshot; and publishing the global state snapshot to all control entry points through an edge collaborative network to achieve state synchronization. In this embodiment of the invention, by constructing an intent dependency graph and combining it with the simulated execution of a unified state machine model, a systematic identification and detection of intent conflicts at multiple entry points is achieved, ensuring that conflict detection covers all potential scenarios. Furthermore, a reinforcement learning dynamic arbitration strategy is adopted to adjudicate conflicting intents in real time. Its adaptive capability can generate the optimal winning intent sequence under different scenarios and historical interaction modes, fundamentally avoiding state rollback and uncertainty in final behavior. At the same time, the global state is uniformly updated and a snapshot is generated based on the winning sequence, and then synchronized to all entry points through an edge collaborative network, ensuring strong consistency in the state display of each terminal and significantly improving the accuracy and overall reliability of the system when controlling multiple entry points concurrently. Attached Figure Description

[0031] Figure 1 This is a schematic diagram of one embodiment of the multi-entry intention collaborative control method in this invention; Figure 2 This is a schematic diagram of another embodiment of the multi-entry intention collaborative control method in this invention; Figure 3 This is a schematic diagram of one embodiment of the multi-entry intentional collaborative control device in this invention. Figure 4 This is a schematic diagram of another embodiment of the multi-entry intentional collaborative control device in this invention; Figure 5 This is a schematic diagram of one embodiment of the electronic device in this invention. Detailed Implementation

[0032] This invention provides a multi-entry intention collaborative control method, apparatus, device, and storage medium. By constructing an intention dependency graph to simulate conflicts and perform intelligent dynamic arbitration based on reinforcement learning, it ultimately achieves strong consistency synchronization of the global state, thereby significantly improving the accuracy, system reliability, and user experience of multi-entry intelligent device control.

[0033] The terms "first," "second," "third," "fourth," etc. (if present) in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" or "having" and any variations thereof are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0034] It is understood that the executing entity of this invention can be a multi-entry intent collaborative control device, a terminal, or a server; the specific implementation is not limited here. This embodiment of the invention will be described using a server as the executing entity as an example.

[0035] For ease of understanding, the specific process of the embodiments of the present invention is described below. Please refer to [link / reference]. Figure 1 One embodiment of the multi-entry intent collaborative control method in this invention includes: 101. Obtain intent commands from multiple control entry points and construct an intent dependency graph; An intent receiving gateway is established on the device side to listen for and receive standardized commands reported from various control entry points, such as mobile applications, physical remote controls, voice assistants, and device panel buttons, in real time. Each command includes the intent type, target parameters, a unique entry identifier, a precise timestamp, and the device's global state version number on which it is based. The system dynamically constructs and maintains an intent dependency graph based on the logical relationships between commands and the mutual exclusion of state resources. This graph uses commands as nodes and dependencies as edges. Dependency types include temporal dependencies, resource mutual exclusion dependencies, and logical causal dependencies. Examples of temporal dependencies include subsequent commands waiting for preceding commands to complete; resource mutual exclusion dependencies include multiple commands competing for control of the same audio source; and logical causal dependencies include the requirement to join a group before synchronizing the volume within that group.

[0036] 102. Based on the intent instructions and intent dependency graph, simulate execution using a preset unified state machine model to detect and identify conflicting intents, and obtain a set of conflicting intents; The constructed intent dependency graph is topologically sorted to generate one or more theoretically conflict-free execution sequences, and one of these sequences is selected as the simulation order. Then, in a completely isolated simulation copy of the unified state machine model, the system sequentially calls the state transition function corresponding to each intent instruction in this order for simulation execution. During simulation, the system uses a fine-grained state write tracker to record the write operations and values ​​of each instruction to each state field in real time. When the tracker detects that multiple intent instructions have written to the same state field within the same simulation cycle, it triggers a write-write conflict check, determining the conflict by comparing the logical mutual exclusion of the written values ​​or the called functions. Simultaneously, after each instruction is executed, the system immediately captures an intermediate state snapshot of the simulation copy and sends it to the rule engine and constraint checker to verify whether it violates predefined state transition rules or business constraints. All intent instructions marked as having write-write conflicts or logical conflicts are collected and integrated into a conflict intent set. 103. Based on a reinforcement learning dynamic arbitration strategy, adjudicate the set of conflicting intentions to obtain the winning intention instruction sequence; The system extracts the operation target field, conflict type identifier, and current values ​​of relevant state fields for each conflicting intent. These values ​​are then concatenated and standardized with the real-time collected system performance metric load vector to form a high-dimensional arbitration state vector. This vector is subsequently input into a pre-trained deep reinforcement learning arbitration model. This model employs a deep deterministic policy gradient architecture, whose policy network outputs a probability distribution of a ruling action for each intent in the conflicting intent set based on the input state vector. The ruling actions include "execute," "modify," "delay," or "reject." The system executes decisions based on the arbitration action vector output by the model: intents marked "execute" are retained; for intents marked "modify," a parameter optimizer is invoked to adjust their operation parameters according to a preset policy; intents marked "delay" are added to the execution queue; and intents marked "reject" are discarded. Finally, the system reorders the processed intents according to business priority and dependencies, generating a winning intent instruction sequence.

[0037] 104. Update the global state of the unified state machine model according to the winning intention instruction sequence, and generate a global state snapshot; An atomic transaction is initiated to execute the winning intent sequence. This transaction locks the global state storage of the unified state machine model and, strictly following the sequence order, calls the state transition function corresponding to each intent to update the global state in-place, ensuring that all changes are either fully committed or fully rolled back. After a successful transaction commit, the system calculates a SHA-256 hash value for the updated global state data, serving as the unique state root. Next, the system constructs an original state snapshot data packet containing the state root hash, the Merkle tree digest of the winning intent sequence, a monotonically increasing state version identifier, and the current timestamp. Finally, the system uses the RSA private key held by the control center to digitally sign this structured data packet and appends the signature to the end of the packet, thereby generating a global state snapshot with integrity and non-repudiation.

[0038] 105. Publish global state snapshots to all control entry points through the edge collaboration network to achieve state synchronization.

[0039] A global state snapshot is encoded into a compact binary message using Protocol Buffers. This message is then efficiently distributed to all online control entry nodes via a reliable UDP-based multicast protocol in the edge collaborative network. Upon receiving the message, each control entry node first deserializes it, separating the data payload and digital signature. Next, the entry node uses a pre-securely stored control hub public key to verify the signature, ensuring the snapshot's integrity and authenticity. After successful verification, the entry node parses the version identifier field in the snapshot and compares it with the previously persisted version identifier. Only if the received version identifier is significantly greater than the local version will the entry node accept the snapshot and verify and update its local state copy based on the state root hash value in the snapshot, ensuring complete consistency with the global state and achieving final state synchronization. Snapshots with the same or older versions are discarded to avoid duplication or rollback operations.

[0040] In this embodiment of the invention, by constructing an intent dependency graph and combining it with the simulated execution of a unified state machine model, a systematic identification and detection of intent conflicts at multiple entry points is achieved, ensuring that conflict detection covers all potential scenarios. Furthermore, a reinforcement learning dynamic arbitration strategy is adopted to adjudicate conflicting intents in real time. Its adaptive capability can generate the optimal winning intent sequence under different scenarios and historical interaction modes, fundamentally avoiding state rollback and uncertainty in final behavior. At the same time, the global state is uniformly updated and a snapshot is generated based on the winning sequence, and then synchronized to all entry points through an edge collaborative network, ensuring strong consistency in the state display of each terminal and significantly improving the accuracy and overall reliability of the system when controlling multiple entry points concurrently.

[0041] Please see Figure 2Another embodiment of the multi-entry intent collaborative control method in this invention includes: 201. Receive intent commands from multiple control entry points, extract the target state field, operation type, and operation parameters operated by each intent command, and generate a standardized intent description object; The received intent command is parsed to identify verbs, objects, and modifiers, which are then mapped to operation type, target state field, and operation parameters, respectively. The operation type, target state field, and operation parameters are then filled into a structured data template according to a predefined pattern to form a primary intent object. Semantic disambiguation and unit standardization are performed on the primary intent object to generate a standardized intent description object with unified semantics and measurement units.

[0042] The received intent command is input into a pre-trained lexical-syntactic analyzer built on a dependency parsing model. First, the analyzer performs word segmentation and part-of-speech tagging on the command, identifying the core predicate verb in the sentence, which is directly mapped to the operation type. Next, the analyzer establishes a dependency tree of subject-verb-object and modifier-adverb-complement relationships to find the direct object noun phrase governed by the predicate verb as the core target of the operation. For example, in "increase the CPU utilization limit of server A to 80%", the core object "CPU utilization limit" is identified and further mapped to a precise state field path within the system using a pre-built domain ontology library. Simultaneously, the analyzer extracts all modifiers attached to the verb and object, especially prepositional phrases, adverbs, and numerical quantifiers. For example, the "to" in "increase to" combined with the following "80%" is parsed as an operation parameter; while the modifier "of server A" is identified as the limiting range of the target field and integrated into the aforementioned field path mapping process. Ultimately, all the parsed elements are structured into an intermediate representation containing an enumeration of operation types, a string representing the target state field, and a dictionary of operation parameters.

[0043] A predefined structured data template based on protocol patterns specifies core attributes and their value types, such as operation type, target field, and execution parameters. During the population process, the parsed verbs are first matched against a predefined standard operation vocabulary; for example, "set" is mapped to "modify," and "read" is mapped to "query." This standard vocabulary is then filled into the operation type attribute. For the target state field, the complete hierarchical path string obtained through domain ontology mapping, such as "server.A.resource.CPU.utilization cap," is directly filled into the target field attribute. For operation parameters, the parsed raw parameters are structurally encapsulated according to the semantic framework of the current operation type. For example, for the description "increase to 80%," the system constructs a parameter object containing the specific value 80, the unit "percentage," and a pattern field representing the parameter's semantics, with a value of "absolute assignment." Finally, this parameter object is assigned to the execution parameter attribute, thus generating a well-formatted primary intent object.

[0044] The core vocabulary in the initial intent object, such as the natural language terms in the operation type and target field, is matched against a pre-built domain knowledge graph. This knowledge graph defines the authoritative meaning and synonym relationships of all terms in a specific context. For example, when the operation type is "modify" and the target field contains "memory," the knowledge graph determines that in the server resource context, "memory" specifically refers to "random access memory" rather than a storage disk, and maps it uniformly to the standard term "RAM." Next, unit standardization is performed, identifying possible combinations of values ​​and units in the execution parameter object, such as "80%" or "2GB," and using a physical quantity unit conversion library to uniformly convert all non-standard units or relative percentages to the system's internally defined benchmark units. For example, the percentage representation of CPU utilization is converted to a decimal utilization value based on the server model's calculation benchmark, and "GB" is converted to an integer value in "bytes." Finally, a standardized intent description object is output, with all terms derived from a controlled vocabulary and all values ​​based on benchmark units of measurement.

[0045] 202. Analyze the semantic relationships between standardized intent description objects, identify the explicit dependencies between intent instructions at the state read and write levels, and the implicit dependencies based on preset business rules and state field mapping relationships; By comparing the target state field sets operated on by any two standardized intent description objects, the semantics of data flow between them are analyzed to identify explicit dependencies caused by writing before reading or reading before writing the same field. By inputting standardized intent description objects into a preset rule reasoning engine, the business logic semantics between their operation targets and parameters are analyzed. Based on the predefined business rule graph and state field mapping relationship, implicit dependencies that have logical premise, causal, or deductive relationships are identified.

[0046] For explicit dependencies, each standardized intent description object is treated as a node, and the field paths in its target field attributes are extracted to construct a temporary field access relationship matrix. By traversing all intent pairs, the system analyzes their access patterns to the same field path: if intent A's operation on a certain field is "write," while intent B's operation on that field is "read," then the system determines that there is an explicit data flow dependency from A to B; conversely, if A is "read" and B is "write," then there is a potential read-then-write dependency from A to B. For implicit dependencies, each intent description object is converted into a set of fact assertions consisting of operation type, target field, and parameters, and input into an inference engine based on the Drools rule engine. This inference engine loads a predefined business rule graph, which contains logical rules such as "if intent X modifies the server power state, then the query result of intent Y on application service availability will change accordingly," as well as the state mapping relationship between the "server power state field" and the "application service health state field." Through forward chain reasoning, the engine can automatically deduce the implicit logical dependencies such as causality and premises between intentions and output these dependencies as directed edges.

[0047] 203. Treat each intent instruction as a node, and the identified explicit and implicit dependencies as directed edges, to construct an intent dependency graph that reflects the operation order and causal logic among all intent instructions. Using the standardized intent description object corresponding to each intent instruction as an attribute, a unique graph node is created, forming the node set of the intent dependency graph. Based on the identified explicit and implicit dependencies, directed edges are established between the corresponding graph nodes, where the direction of the edges points from the source intent in the dependency relationship to the target intent, forming the edge set of the intent dependency graph. Based on the node set and the edge set, the final directed graph structure is generated as the intent dependency graph. The topological order of the intent dependency graph represents the theoretical execution order when there are no conflicts between intent instructions.

[0048] For each intent instruction, a unique timestamp-hash combination identifier is generated as the node ID. The entire standardized intent description object corresponding to the instruction, including its standard operation type, precise target field path, and transformed parameter values, is serialized into a JSON string and stored as the core attribute of the graph node. All nodes constitute the initial set. Subsequently, all identified dependency entries are traversed. Each dependency explicitly records the source intent ID and the target intent ID. Based on these records, a directed edge is created in the attribute graph, with the starting point of the edge being the node corresponding to the source intent ID and the ending point being the node corresponding to the target intent ID. Simultaneously, the system appends the type of dependency as an attribute to this edge, such as labeling it as "data dependency" or "business rule dependency." Finally, the graph database operation interface is called to commit all created nodes and directed edges as a single transaction, thereby generating a complete and queryable intent dependency graph data structure.

[0049] 204. Following a topological sorting sequence of the intent dependency graph, sequentially simulate the execution of each intent instruction on a simulation copy of the unified state machine model; Obtain the adjacency list representation of the intent dependency graph, and generate at least one topological sorting sequence using a depth-first or breadth-first search algorithm; select one of the topological sorting sequences as the instruction order for the current simulation execution; maintain a virtual global state and instruction execution log in the simulation copy of the unified state machine model, and call the state transition function corresponding to each intent instruction for simulation execution according to the selected sequence order.

[0050] The intent dependency graph is converted into an in-memory adjacency list data structure, where each node key corresponds to an intent identifier, and its value is a list of identifiers of all subsequent nodes directly reachable from that node. The topology sorting generator uses a depth-first search algorithm: first, an empty result stack and a hash table recording the node access status are initialized; then, each unvisited node is recursively visited. When visiting a node, the algorithm recursively visits all its adjacent nodes to ensure all subsequent dependent nodes are processed, and then pushes the node onto the result stack, ultimately obtaining a reversed topology sequence. Popping elements from the stack sequentially yields a correct topology sort. From all generated possible sequences, the first completed sequence is selected as the instruction execution order for this simulation. Next, a copy of the simulation state machine isolated from the production environment is initialized. This copy contains a virtual global state dictionary and a blank execution log. The simulation execution engine strictly follows the selected topology sequence, parses the standardized description object corresponding to each intent identifier in turn, extracts the state transition function pointer and parameters from it, and calls the function on the virtual global state. At the same time, it records the state snapshots, parameters and return values ​​before and after the function call in detail in the execution log, thereby completing the simulation and deduction of the entire sequence.

[0051] 205. During the simulation execution, monitor concurrent write operations to the same status field. If the write value or operation logic is incompatible, mark the relevant intent instruction as having a write-write conflict. The simulation execution log records the write operation and the written value of each intent instruction to each status field. When it is detected that two or more intent instructions have initiated write operations to the same status field within the same simulation execution cycle, a write-write conflict check is triggered. If these write operations are compared, and their written values ​​are definite and different from each other, or the write functions they call are logically mutually exclusive, they are determined to be irreconcilable, and a write-write conflict is marked between all intent instructions involving writing to that field.

[0052] During simulation execution, a detailed log entry is created for the execution of each intent command. This entry contains not only the command ID but also a list of write operations. Each item in the list records the complete path of the state field being written, the original value before the write, the new value after the write, and the identifier of the specific write function called. The simulation execution engine maintains a global field write tracker, which is a hash map with the state field path as the key and the list of intent command IDs as the value. Whenever a command completes simulation execution, the engine iterates through its log's list of write operations, appending the current command ID to the command list for the corresponding field path in the tracker. After a complete topology sequence simulation execution is completed, the engine iterates through this tracker, checking the list of command IDs corresponding to each field path. If the length of a list is greater than one, it indicates that the field was written by multiple intents during this simulation cycle, triggering conflict analysis. The analyzer extracts the specific log entries corresponding to these commands and compares them: First, it determines whether the written value is a definite literal or a calculation result. If both are definite values ​​and are unequal, it is determined to be a numerical conflict. Second, by querying a predefined function mutex table, it checks whether the write functions called by these commands are marked as logically mutually exclusive. For example, a "set to maximum value" function and a "set to minimum value" function are usually mutually exclusive. If mutual exclusion exists, it is determined to be a logical conflict. Once any conflict is confirmed, the system generates a conflict event, which includes the conflicting field path and all involved intent command IDs, and marks these commands as having a write-write conflict relationship.

[0053] 206. During the simulation execution, the execution result of each intent instruction is verified according to the preset state transition rules and business constraints. If any rule or constraint is violated, the corresponding intent instruction is marked as having a logical conflict; and the conflicting intent instructions are integrated into a conflict intent set. After each intent instruction is simulated and executed, the intermediate state of the simulation copy is immediately captured; the intermediate state is matched and verified against all predefined state transition rules in the unified state machine model to check for any violated rules; the intermediate state is logically judged against preloaded business constraints to check if it exceeds the constraint range; if any rule is violated or any constraint is exceeded, the execution result of the intent instruction is determined to be illegal and marked as a logical conflict.

[0054] After the state transition function corresponding to each intent instruction has finished executing in the simulation copy, the snapshot function is invoked to perform a deep copy of all key-value pairs in the virtual global state dictionary at this time, generating a complete intermediate state snapshot object. This snapshot object is then sent to the rule validation engine. The engine first loads the predefined state transition rule library in the unified state machine model, which exists in the form of "event-condition-action". It uses the operation type of the current intent instruction and the intermediate state as input events, matching the conditional assertions in the rules one by one. For example, it verifies whether a rule like "hardware disassembly is not allowed when the server state is 'running'" is violated. Simultaneously, the intermediate state snapshot is also sent to the constraint checker. This checker uses a Boolean expression evaluator to determine the preloaded global business constraints. These constraints might be in the form of "the total CPU utilization of all servers must be less than 90%" or "the number of instances of service A must be greater than or equal to 3". The rule validation engine and constraint checker then summarize all validation failures, including specific rule entries violated or constraints broken. If the summary result is not empty, that is, there is at least one violation, then the execution of the current intent instruction is determined to have resulted in an illegal state. A logical conflict flag is then generated, which is associated with the current intent instruction ID and records all violation rules and constraints in detail.

[0055] 207. Based on a reinforcement learning dynamic arbitration strategy, adjudicate the set of conflicting intentions to obtain the winning intention instruction sequence; The operation target, conflict type identifier, and associated state field value in the unified state machine model are extracted from each conflict intent in the conflict intent set. These are then concatenated with the system's performance metric load vector to form an arbitration state vector. The arbitration state vector is input into a pre-trained reinforcement learning arbitration model. Based on its policy network, the reinforcement learning arbitration model outputs an arbitration action vector. Each dimension of the arbitration action vector corresponds to an intent in the conflict intent set, and its value represents the adjudication operation for that intent. The adjudication operation includes execution, modification, delay, or rejection. Based on the arbitration action vector, the intents in the conflict intent set are filtered and reconstructed to obtain the winning intent instruction sequence.

[0056] The system extracts core features from each conflict intent in the conflict intent set: the target field path in its standardized description object is used as the operation target; strings such as "write-write conflict" or "logical conflict" marked by the detection system are used as conflict type identifiers; and the latest values ​​of these target field paths in the unified state machine model are queried in real time. Simultaneously, the system obtains a multi-dimensional performance metric load vector from the monitoring module, which contains real-time data such as CPU utilization, memory usage, and network latency. Then, a feature encoder is used to standardize and vectorize this heterogeneous information. Specifically, the operation target is converted into a dense vector through an embedding layer, the conflict type is one-hot encoded, and the state field values ​​are normalized to scalars. Finally, all encoded feature vectors are concatenated with the load vector to form a fixed-dimensional arbitration state vector. This vector is input into a neural network model pre-trained based on a deep deterministic policy gradient method. The model's policy network consists of multiple fully connected layers, and its output layer uses a Softmax function to independently generate a probability distribution for each intent in the conflict intent set, corresponding to four arbitration operations, thus outputting an arbitration action vector. The decision is made based on the ruling operation with the highest probability in the vector: the intent marked "execute" is directly added to the winning sequence; for the intent marked "modify", the parameter adjuster is called to modify its parameters according to the preset strategy before adding it; the intent marked "delay" is temporarily stored in the pending queue; the intent marked "reject" is directly discarded, and finally a winning intent instruction sequence that can be executed immediately is generated.

[0057] Furthermore, before inputting the arbitration state vector into the reinforcement learning model, a multi-dimensional priority scoring algorithm for conflict intent is inserted as an auxiliary decision-making mechanism, the formula of which is:

[0058] in, The overall priority score for the i-th conflict intention is [0,1]. Priority is determined by timing. The criticality of the state is defined, with a value range of [0,1]. The impact on user experience is represented, with a value range of [0,1]. The entry point credibility is set, with a value range of [0,1]. This is a dependency complexity penalty term, with a value range of [0,1]. These are the weighting coefficients, and their sum is 1.

[0059] The timing priority is:

[0060] in, The current timestamp (in seconds); Let i be the timestamp (in seconds) of intention i, and k be the time decay coefficient, for example, k is 0.1.

[0061] State criticality is:

[0062] in, Preset weights for the status fields of the intention i operation.

[0063] The impact on user experience is:

[0064] in, This represents the estimated increase in user satisfaction for intention i.

[0065] The credibility of the entry point is:

[0066] in, The entry reliability score is given for intention i.

[0067] The dependency complexity penalty term is:

[0068] in, Let i be the degree of the node in the dependency graph.

[0069] For example, in a typical multi-entry volume control conflict scenario, the system simultaneously receives three intent commands from different entry points: Intent A, from the mobile app, issued the command "Set volume to 50" 10 seconds ago, operating on the volume field (weight 8); Intent B, from the physical remote control, issued the command "Set volume to 80" 2 seconds ago, also operating on the volume field (weight 8); Intent C, from the voice assistant, issued the "Mute" command 5 seconds ago, which involves both volume and power fields (combined weight 18). The algorithm calculates the comprehensive priority score of each intent based on preset weight coefficients (α=0.3, β=0.25, γ=0.2, δ=0.15, λ=0.1), the credibility of each entry point (mobile app=7, remote control=9, voice=7), the user experience impact value (A=60, B=70, C=85), and the node degree in the dependency graph (A=2, B=1, C=3). The calculated scores are: Intent A: PA = 0.408, Intent B: PB = 0.556, and Intent C: PC = 0.508. Based on the score ranking (PB > PC > PA), the system prioritizes Intent B, the command issued by the physical remote control 2 seconds prior to set the volume to 80. This decision reflects a comprehensive consideration of multiple factors, including timing priority, entry point credibility, and user experience.

[0070] By introducing a multi-dimensional priority scoring mechanism, the accuracy and interpretability of conflict intent arbitration are significantly improved. Its quantitative scoring system comprehensively considers multiple dimensions such as temporal sequence, state criticality, user experience, entry point credibility, and dependency complexity, providing a structured decision-making basis for reinforcement learning models, thereby achieving more accurate and stable adjudication in complex conflict scenarios. Simultaneously, the algorithm possesses good configurability and low computational overhead, supports dynamic weight adjustment according to different scenarios, and can serve as a reliable alternative decision path when the model is uncertain, effectively enhancing the overall robustness and response consistency of the system.

[0071] 208. Update the global state of the unified state machine model according to the winning intention instruction sequence, and generate a global state snapshot; Based on the order and operation logic of the winning intention instruction sequence, state transition operations are executed sequentially in the unified state machine model to complete the atomic update of the global state. Based on the updated global state, the cryptographic hash value of the state data is calculated as the state root, and the state root is encapsulated with the digest information of the winning intention instruction sequence, the state version identifier, and the timestamp information to form an original state snapshot. The original state snapshot is digitally signed to generate a global state snapshot, wherein the digital signature is generated using the private key of the control center.

[0072] An atomic transaction is initiated to execute the winning intent sequence. First, the global state storage of the unified state machine model is locked. Then, each intent instruction is traversed strictly according to the sequence order. Based on the operation type and parameters in its standardized description object, the corresponding state transition function is called to update the global state dictionary in-situ. All update operations are completed within this transaction, ensuring that either all take effect or all are rolled back. After the transaction is successfully committed, the entire updated global state dictionary is serialized using the SHA-256 algorithm, and its hash value is calculated. The resulting 256-bit hash digest is the state root. Subsequently, a raw state snapshot data packet is constructed. This packet contains the following fields in binary format: version number identifier, current timestamp accurate to nanoseconds, Merkle root hash of the winning intent instruction sequence itself as its digest, the calculated state root hash value, and a reserved extension field. Finally, using the RSA private key held by the control center, this structured raw state snapshot data packet is digitally signed using the PKCS#1 v1.5 standard. The generated signature is appended to the end of the data packet, thus forming a complete and tamper-proof global state snapshot.

[0073] 209. Publish the global state snapshot to all control entry points through the edge collaboration network to achieve state synchronization.

[0074] The global state snapshot is encoded into a bearer message of a preset network protocol and distributed through the multicast or broadcast channel of the edge collaborative network. After receiving the bearer message, each control entry point extracts the global state snapshot and verifies the digital signature of the global state snapshot using the pre-stored control center public key. After the signature verification is successful, the state version identifier in the global state snapshot is parsed and compared with the previous state version identifier stored locally. If the state version identifier is updated, the snapshot is accepted, and the local state copy is verified and updated based on the state root in the global state snapshot to complete the state synchronization. If the version is the same or older, the snapshot is discarded.

[0075] Protocol Buffers is used as the serialization protocol to strictly encode the global state snapshot, including the signature and payload, into a binary bearer message according to the predefined .proto pattern, and distribute it through a reliable multicast protocol based on UDP in the edge collaborative network. Upon receiving the message, each control entry point first deserializes it, separating the original state snapshot data packet and the attached RSA signature. The verification module uses the pre-securely stored control center public key to calculate the digest of the data packet using the same SHA-256 hash algorithm. It then uses the public key to decrypt the received signature and compares the calculated digest with the decrypted digest to verify integrity and authenticity. After successful signature verification, the parsing module extracts the version identifier field from the data packet. This identifier is a monotonically increasing 64-bit integer, which the entry point compares with its locally persisted version identifier. If the received version identifier is significantly greater than the local identifier, the entry point accepts the snapshot and enters the state update process: it uses the state root hash in the snapshot as a checksum to reconstruct or repair its own local state copy, ensuring that the hash value calculated by the local state is consistent with the state root, thereby completing the synchronization; if the version identifier is less than or equal to the local identifier, the snapshot is considered expired or duplicate data, and the entry point will directly discard it and record it in the log.

[0076] In this embodiment of the invention, by standardizing intent descriptions and constructing intent dependency graphs, a comprehensive and accurate characterization of explicit and implicit dependencies among multiple entry intents is achieved. This allows for the systematic identification of all potential conflicts, including write-write conflicts and logical conflicts, within a unified state machine simulation replica. A dynamic arbitration strategy based on reinforcement learning intelligently adjudicates conflicts according to real-time scenarios and historical experience, generating a globally consistent winning intent sequence, effectively avoiding state rollback and behavioral uncertainty. Finally, through real-time synchronization of global state snapshots and edge collaborative networks, strong consistency in the display of all control entry states and the final accuracy of control are ensured, significantly improving the reliability and user experience of multi-entry control of intelligent audio devices in complex concurrent scenarios.

[0077] The multi-entry intent coordination control method in the embodiments of the present invention has been described above. The multi-entry intent coordination control device in the embodiments of the present invention is described below. Please refer to [link / reference]. Figure 3 One embodiment of the multi-entry intent collaborative control device in this invention includes: Module 301 is used to obtain intent commands from multiple control entry points and construct an intent dependency graph; The identification module 302 is used to simulate execution based on a preset unified state machine model according to the intent instruction and intent dependency graph, so as to detect and identify conflicting intents and obtain a set of conflicting intents; The adjudication module 303 is used to adjudicate the set of conflicting intentions based on a reinforcement learning dynamic arbitration strategy to obtain the winning intention instruction sequence. The generation module 304 is used to update the global state of the unified state machine model according to the winning intention instruction sequence and generate a global state snapshot. The synchronization module 305 is used to publish a global state snapshot to all control entry points through the edge collaboration network to achieve state synchronization.

[0078] In this embodiment of the invention, by constructing an intent dependency graph and combining it with the simulated execution of a unified state machine model, a systematic identification and detection of intent conflicts at multiple entry points is achieved, ensuring that conflict detection covers all potential scenarios. Furthermore, a reinforcement learning dynamic arbitration strategy is adopted to adjudicate conflicting intents in real time. Its adaptive capability can generate the optimal winning intent sequence under different scenarios and historical interaction modes, fundamentally avoiding state rollback and uncertainty in final behavior. At the same time, the global state is uniformly updated and a snapshot is generated based on the winning sequence, and then synchronized to all entry points through an edge collaborative network, ensuring strong consistency in the state display of each terminal and significantly improving the accuracy and overall reliability of the system when controlling multiple entry points concurrently.

[0079] Please see Figure 4 Another embodiment of the multi-entry intentional collaborative control device in this invention includes: Module 301 is used to obtain intent commands from multiple control entry points and construct an intent dependency graph; The identification module 302 is used to simulate execution based on a preset unified state machine model according to the intent instruction and intent dependency graph, so as to detect and identify conflicting intents and obtain a set of conflicting intents; The adjudication module 303 is used to adjudicate the set of conflicting intentions based on a reinforcement learning dynamic arbitration strategy to obtain the winning intention instruction sequence. The generation module 304 is used to update the global state of the unified state machine model according to the winning intention instruction sequence and generate a global state snapshot. The synchronization module 305 is used to publish a global state snapshot to all control entry points through the edge collaboration network to achieve state synchronization.

[0080] Optionally, building module 301 includes: The generation unit 3011 is used to receive intent instructions from multiple control entry points, extract the target state field, operation type and operation parameters operated by each intent instruction, and generate a standardized intent description object. The identification unit 3012 is used to analyze the semantic relationships between standardized intent description objects, identify the explicit dependencies between intent instructions at the state read and write level, and the implicit dependencies based on preset business rules and state field mapping relationships. Construction unit 3013 is used to construct an intent dependency graph that reflects the operation order and causal logic among all intent instructions, using each intent instruction as a node and the identified explicit and implicit dependencies as directed edges.

[0081] Optionally, the generating unit 3011 can be specifically used for: The received raw intent command is parsed to identify verbs, objects, and modifiers, which are then mapped to operation type, target state field, and operation parameters, respectively. The operation type, target state field, and operation parameters are then filled into a structured data template according to a predefined pattern to form a primary intent object. Semantic disambiguation and unit standardization are performed on the primary intent object to generate a standardized intent description object with unified semantics and measurement units.

[0082] Optionally, the identification unit 3012 can be specifically used for: By comparing the target state field sets operated on by any two standardized intent description objects, the semantics of data flow between them are analyzed to identify explicit dependencies caused by writing before reading or reading before writing the same field. By inputting standardized intent description objects into a preset rule reasoning engine, the business logic semantics between their operation targets and parameters are analyzed. Based on the predefined business rule graph and state field mapping relationship, implicit dependencies that have logical premise, causal, or deductive relationships are identified.

[0083] Optionally, the construction unit 3013 can be specifically used for: Using the standardized intent description object corresponding to each intent instruction as an attribute, a unique graph node is created, forming the node set of the intent dependency graph. Based on the identified explicit and implicit dependencies, directed edges are established between the corresponding graph nodes, where the direction of the edges points from the source intent in the dependency relationship to the target intent, forming the edge set of the intent dependency graph. Based on the node set and the edge set, the final directed graph structure is generated as the intent dependency graph. The topological order of the intent dependency graph represents the theoretical execution order when there are no conflicts between intent instructions.

[0084] Optionally, the recognition module 302 includes: Execution unit 3021 is used to sequentially simulate the execution of each intent instruction on a simulation copy of the unified state machine model according to a topological sorting sequence of the intent dependency graph. The first marking unit 3022 is used to monitor concurrent write operations to the same status field during the simulation execution process. If the write value or operation logic is incompatible, the marking unit will mark the relevant intent instruction as having a write-write conflict. The second marking unit 3023 is used to verify the execution result of each intent instruction according to the preset state transition rules and business constraints during the simulation execution process. If any rule or constraint is violated, the corresponding intent instruction is marked as having a logical conflict.

[0085] Optionally, execution unit 3021 can be specifically used for: Obtain the adjacency list representation of the intent dependency graph, and generate at least one topological sorting sequence using a depth-first or breadth-first search algorithm; select one of the topological sorting sequences as the instruction order for the current simulation execution; maintain a virtual global state and instruction execution log in the simulation copy of the unified state machine model, and call the state transition function corresponding to each intent instruction for simulation execution according to the selected sequence order.

[0086] Optionally, the first marking unit 3022 can be specifically used for: The simulation execution log records the write operation and the written value of each intent instruction to each status field. When it is detected that two or more intent instructions have initiated write operations to the same status field within the same simulation execution cycle, a write-write conflict check is triggered. If these write operations are compared, and their written values ​​are definite and different from each other, or the write functions they call are logically mutually exclusive, they are determined to be irreconcilable, and a write-write conflict is marked between all intent instructions involving writing to that field.

[0087] Optionally, the second marking unit 3023 can be specifically used for: After each intent instruction is simulated and executed, the intermediate state of the simulation copy is immediately captured; the intermediate state is matched and verified against all predefined state transition rules in the unified state machine model to check for any violated rules; the intermediate state is logically judged against preloaded business constraints to check if it exceeds the constraint range; if any rule is violated or any constraint is exceeded, the execution result of the intent instruction is determined to be illegal and marked as a logical conflict.

[0088] Optionally, the adjudication module can be specifically used for: The operation target, conflict type identifier, and associated state field value in the unified state machine model are extracted from each conflict intent in the conflict intent set. These are then concatenated with the system's performance metric load vector to form an arbitration state vector. The arbitration state vector is input into a pre-trained reinforcement learning arbitration model. Based on its policy network, the reinforcement learning arbitration model outputs an arbitration action vector. Each dimension of the arbitration action vector corresponds to an intent in the conflict intent set, and its value represents the adjudication operation for that intent. The adjudication operation includes execution, modification, delay, or rejection. Based on the arbitration action vector, the intents in the conflict intent set are filtered and reconstructed to obtain the winning intent instruction sequence.

[0089] Optionally, the generation module can be specifically used for: Based on the order and operation logic of the winning intention instruction sequence, state transition operations are executed sequentially in the unified state machine model to complete the atomic update of the global state. Based on the updated global state, the cryptographic hash value of the state data is calculated as the state root, and the state root is encapsulated with the digest information of the winning intention instruction sequence, the state version identifier, and the timestamp information to form an original state snapshot. The original state snapshot is digitally signed to generate a global state snapshot, wherein the digital signature is generated using the private key of the control center.

[0090] Optionally, the synchronization module can be specifically used for: The global state snapshot is encoded into a bearer message of a preset network protocol and distributed through the multicast or broadcast channel of the edge collaborative network. After receiving the bearer message, each control entry point extracts the global state snapshot and verifies the digital signature of the global state snapshot using the pre-stored control center public key. After the signature verification is successful, the state version identifier in the global state snapshot is parsed and compared with the previous state version identifier stored locally. If the state version identifier is updated, the snapshot is accepted, and the local state copy is verified and updated based on the state root in the global state snapshot to complete the state synchronization. If the version is the same or older, the snapshot is discarded.

[0091] In this embodiment of the invention, by standardizing intent descriptions and constructing intent dependency graphs, a comprehensive and accurate characterization of explicit and implicit dependencies among multiple entry intents is achieved. This allows for the systematic identification of all potential conflicts, including write-write conflicts and logical conflicts, within a unified state machine simulation replica. A dynamic arbitration strategy based on reinforcement learning intelligently adjudicates conflicts according to real-time scenarios and historical experience, generating a globally consistent winning intent sequence, effectively avoiding state rollback and behavioral uncertainty. Finally, through real-time synchronization of global state snapshots and edge collaborative networks, strong consistency in the display of all control entry states and the final accuracy of control are ensured, significantly improving the reliability and user experience of multi-entry control of intelligent audio devices in complex concurrent scenarios.

[0092] above Figure 3 and Figure 4 The multi-entry intent collaborative control device in the embodiments of the present invention will be described in detail from the perspective of modular functional entities. The electronic device in the embodiments of the present invention will be described in detail from the perspective of hardware processing.

[0093] See Figure 5 As shown, the electronic device includes a processor 500 and a memory 501. The memory 501 stores machine-executable instructions that can be executed by the processor 500. The processor 500 executes the machine-executable instructions to implement the above-described multi-entry intention cooperative control method.

[0094] Furthermore, Figure 5 The electronic device shown also includes a bus 502 and a communication interface 503. The processor 500, the communication interface 503 and the memory 501 are connected via the bus 502.

[0095] The memory 501 may include high-speed random access memory (RAM) and may also include non-volatile memory, such as at least one disk storage device. Communication between this system network element and at least one other network element is achieved through at least one communication interface 503 (which can be wired or wireless), such as the Internet, wide area network, local area network, metropolitan area network, etc. The bus 502 may be an ISA bus, PCI bus, or EISA bus, etc. The bus can be divided into address bus, data bus, control bus, etc. For ease of representation, Figure 5 The symbol is represented by a single double-headed arrow, but this does not mean that there is only one bus or one type of bus.

[0096] The processor 500 may be an integrated circuit chip with signal processing capabilities. In implementation, each step of the above method can be completed by the integrated logic circuitry in the hardware of the processor 500 or by instructions in software form. The processor 500 may be a general-purpose processor, including a central processing unit (CPU), a network processor (NP), etc.; it may also be a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. It can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of this disclosure. The general-purpose processor may be a microprocessor or any conventional processor. The steps of the methods disclosed in the embodiments of this disclosure can be directly embodied in the execution of a hardware decoding processor, or executed by a combination of hardware and software modules in the decoding processor. The software modules may reside in random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, registers, or other mature storage media in the art. The storage medium is located in memory 501. The processor 500 reads the information in memory 501 and, in conjunction with its hardware, completes the method steps of the aforementioned embodiment.

[0097] The present invention also provides an electronic device, the computer device including a memory and a processor, wherein the memory stores computer-readable instructions, and when executed by the processor, the computer-readable instructions cause the processor to perform the steps of the multi-entry intention cooperative control method in the above embodiments. The present invention also provides a computer-readable storage medium, which can be a non-volatile computer-readable storage medium or a volatile computer-readable storage medium, wherein the computer-readable storage medium stores instructions, and when the instructions are executed on a computer, the computer causes the computer to perform the steps of the multi-entry intention cooperative control method.

[0098] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0099] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0100] The above-described 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 the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A multi-entry intent coordination control method, characterized by, The multi-entry intent collaborative control method includes: Obtain intent commands from multiple control entry points and construct an intent dependency graph; Based on the intent instructions and the intent dependency graph, simulated execution is performed using a preset unified state machine model to detect and identify conflicting intents, thereby obtaining a set of conflicting intents. The conflicting intent set is adjudicated based on a reinforcement learning dynamic arbitration strategy to obtain the winning intent instruction sequence. Update the global state of the unified state machine model according to the winning intention instruction sequence, and generate a global state snapshot; The global state snapshot is published to all control entry points through the edge collaboration network to achieve state synchronization.

2. The multi-entry intent coordination control method of claim 1, wherein, The step of acquiring intent commands from multiple control entry points and constructing an intent dependency graph includes: It receives intent commands from multiple control entry points, extracts the target state field, operation type, and operation parameters operated by each intent command, and generates a standardized intent description object. Analyze the semantic relationships between the standardized intent description objects, identify the explicit dependencies between intent instructions at the state read and write levels, and the implicit dependencies based on preset business rules and state field mapping relationships; By treating each intent instruction as a node and the identified explicit and implicit dependencies as directed edges, an intent dependency graph is constructed that reflects the operation order and causal logic among all intent instructions.

3. The multi-entry intent coordination control method of claim 2, wherein, The process of extracting the target state field, operation type, and operation parameters operated by each intent instruction, and generating a standardized intent description object, includes: The received original intent command is parsed to identify the verbs, objects, and modifiers, which are then mapped to operation type, target state field, and operation parameters, respectively. The operation type, the target state field, and the operation parameters are filled into a structured data template according to a predefined pattern to form a primary intent object; Semantic disambiguation and unit standardization are performed on the primary intent object to generate a standardized intent description object with unified semantics and measurement units.

4. The multi-entry intent coordination control method of claim 2, wherein, The analysis of the semantic relationships between the standardized intent description objects, identifying explicit dependencies between intent instructions at the state read and write levels, and implicit dependencies based on preset business rules and state field mapping relationships, includes: By comparing the target state field sets operated on by any two standardized intent description objects, the semantics of the data flow between them are analyzed, and explicit dependencies caused by writing before reading or reading before writing on the same field are identified. By inputting the standardized intent description object into a preset rule reasoning engine, the business logic semantics between its operation target and parameters are analyzed. Based on the predefined business rule graph and state field mapping relationship, implicit dependencies that logically have premise, causal or deductive relationships are identified.

5. The multi-entry intent coordination control method of claim 2, wherein, The process involves treating each intent instruction as a node and the identified explicit and implicit dependencies as directed edges to construct an intent dependency graph that reflects the operational order and causal logic among all intent instructions. This includes: Each intent instruction is associated with a standardized intent description object, which is used as an attribute to create a unique graph node, forming a set of nodes in the intent dependency graph. Based on the identified explicit and implicit dependencies, directed edges with direction are established between the corresponding graph nodes, where the direction of the edges points from the source intent to the target intent in the dependency relationship, forming the edge set of the intent dependency graph. Based on the set of nodes and the set of edges, a final directed graph structure is generated as the intent dependency graph. The topological ordering of the intent dependency graph represents the theoretical execution order when there are no conflicts between intent instructions.

6. The multi-entry intent coordination control method of claim 1, wherein, The step of simulating execution based on the intent instruction and the intent dependency graph, using a preset unified state machine model, to detect and identify conflicting intents includes: According to a topological sorting sequence of the intent dependency graph, each intent instruction is sequentially simulated and executed on a simulation copy of the unified state machine model; During the simulation, concurrent write operations to the same status field are monitored. If the write value or operation logic is incompatible, the relevant intent instruction is marked as having a write-write conflict. During the simulation, the execution result of each intent instruction is verified according to the preset state transition rules and business constraints. If any rule or constraint is violated, the corresponding intent instruction is marked as having a logical conflict.

7. The multi-entry intent coordination control method of claim 6, wherein, The step of sequentially simulating the execution of each intent instruction on a simulation copy of the unified state machine model according to a topological sorting sequence of the intent dependency graph includes: Obtain the adjacency list representation of the intent dependency graph, and generate at least one topological sorting sequence using a depth-first or breadth-first search algorithm; Select one of the topological sorting sequences as the order of instructions to be executed in the current simulation; In the simulation copy of the unified state machine model, a virtual global state and instruction execution log are maintained, and the state transition function corresponding to each intention instruction is called in the selected sequence for simulated execution.

8. The multi-entry intent coordination control method of claim 6, wherein, If the monitoring performs concurrent write operations on the same status field, and the write values ​​or operation logic are incompatible, then a write-write conflict is flagged for the relevant intent command, including: The simulated execution log records the write operations and values ​​of each intent command to each status field. When it is detected that two or more intent commands have initiated write operations on the same status field within the same simulation execution cycle, a write-write conflict check is triggered. Comparing these write operations, if their written values ​​are deterministic and distinct, or if the write functions they call are logically mutually exclusive, they are determined to be irreconcilable, and a write-write conflict is marked as existing between all intent instructions involving writing to that field.

9. The multi-entry intent coordination control method of claim 6, wherein, The execution result of each intent instruction is verified according to preset state transition rules and business constraints. If any rule or constraint is violated, the corresponding intent instruction is marked as having a logical conflict, including: Immediately after each intent instruction is simulated and executed, the intermediate state of the simulated copy is captured; The intermediate state is matched and verified against all predefined state transition rules in the unified state machine model to check for any violated rules. The intermediate state is logically compared with the preloaded business constraints to check whether it exceeds the constraint range. If any rule is violated or any constraint is exceeded, the execution result of the intended instruction is deemed illegal and marked as a logical conflict.

10. The multi-entry intent coordination control method of claim 1, wherein, The method of resolving the conflicting intent set based on a reinforcement learning-based dynamic arbitration strategy to obtain the winning intent instruction sequence includes: Extract the operation target, conflict type identifier, and associated state field value in the unified state machine model for each conflict intent in the conflict intent set, and concatenate them with the system's performance index load vector to form an arbitration state vector; The arbitration state vector is input into a pre-trained reinforcement learning arbitration model, which outputs an arbitration action vector based on its policy network. Each dimension of the arbitration action vector corresponds to an intent in the conflict intent set, and its value represents the adjudication operation for that intent. The adjudication operation includes execution, modification, delay, or rejection. Based on the arbitration action vector, the intentions in the conflict intention set are filtered and reconstructed to obtain the winning intention instruction sequence.

11. The multi-entry intent coordination control method of claim 1, wherein, The step of updating the state of the unified state machine according to the winning intention instruction and generating a global state snapshot includes: Based on the order and operation logic of the winning intention instruction sequence, state transition operations are executed sequentially in the unified state machine model to complete the atomic update of the global state. Based on the updated global state, the cryptographic hash value of the state data is calculated as the state root, and the state root is encapsulated with the digest information, state version identifier, and timestamp information of the winning intention instruction sequence to form an original state snapshot; The original state snapshot is digitally signed to generate a global state snapshot, wherein the digital signature is generated using the private key of the control center.

12. The multi-entry intent coordination control method of claim 1, wherein, The step of publishing the global state snapshot to all control entry points through the edge collaboration network to achieve state synchronization includes: The global state snapshot is encoded into a bearer message of a preset network protocol and distributed through the multicast or broadcast channel of the edge collaborative network; After receiving the bearer message, each control entry point extracts the global state snapshot from it and verifies the digital signature of the global state snapshot using the pre-stored control center public key; After the signature verification is successful, the state version identifier in the global state snapshot is parsed and compared with the previous state version identifier stored locally. If the state version identifier is updated, the snapshot is accepted, and the local state copy is verified and updated based on the state root in the global state snapshot to complete the state synchronization. If the version is the same or older, the snapshot is discarded.

13. A multiple entry intent coordination control apparatus characterized by comprising: The multi-entry intent collaborative control device includes: The building module is used to obtain intent commands from multiple control entry points and construct an intent dependency graph; The identification module is used to simulate execution based on a preset unified state machine model according to the intent instruction and the intent dependency graph, so as to detect and identify conflicting intents and obtain a set of conflicting intents; The adjudication module is used to adjudicate the set of conflicting intentions based on a reinforcement learning dynamic arbitration strategy to obtain the winning intention instruction sequence. The generation module is used to update the global state of the unified state machine model according to the winning intention instruction sequence, and generate a global state snapshot; The synchronization module is used to publish the global state snapshot to all control entry points through the edge collaboration network to achieve state synchronization.

14. An electronic device, comprising: The electronic device includes: a memory and at least one processor, wherein the memory stores instructions; The at least one processor invokes the instructions in the memory to cause the electronic device to execute the multi-entry intent cooperative control method as described in any one of claims 1-12.

15. A computer-readable storage medium storing instructions thereon, characterized in that, When the instructions are executed by the processor, they implement the multi-entry intent cooperative control method as described in any one of claims 1-12.

Images