Dynamic graph data processing method based on multi-agent cooperation and double-element ontology

Abstract

This application relates to the field of data processing technology, and in particular to a dynamic graph data processing method based on multi-agent collaboration and a bi-element ontology. The method includes acquiring semantic change events, shared processing link identifiers, mixed operating states of shared processing links, and pre-write link state representations to form event link input objects; determining state transition types and target subgraph regions based on the bi-element ontology, and determining ontology transition binding relationships and reuse pressure states by combining shared processing link identifiers and mixed operating states; generating ontology transition write biases and embedding channel-level write gating into the state update model to form event-attributed write gating; using this gating to control channel-level writing of candidate link states to obtain event-constrained link state representations, and obtaining the event-attributed operating state increment based on the channel difference between the representation and the pre-write link state representation. This application can accurately determine the link operating state changes corresponding to the current semantic change event.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to a dynamic graph data processing method based on multi-agent collaboration and dual-element ontology. Background Technology

[0002] Knowledge graphs typically express domain knowledge through entities, relationships, and attributes, and are used to carry structured semantic information in scenarios such as search and question answering, data governance, business process orchestration, and intelligent operations and maintenance. As business data sources continuously change, the processing objects of knowledge graphs are no longer limited to static queries after offline construction. Instead, they need to continuously process and update graph data when semantic changes occur, such as entity category expansion, the addition of relationship edges, attribute hierarchy changes, and adjustments to the target subgraph structure. In scenarios where multiple agents participate in dynamic graph updates, different agents may trigger data extraction, rule cleaning, caching, task scheduling, or template generation processes in parallel around different target subgraphs. To reduce resource consumption caused by repeated deployment and computation, related processing links are often jointly invoked by multiple target subgraphs. This means that the running state of the same processing link may simultaneously include multiple semantic change events and the impact of shared system load.

[0003] In existing dynamic knowledge graph update technologies, one approach uses influence domain identification to process incremental knowledge units. This approach acquires incremental knowledge units containing new entities and relationships, performs neighborhood retrieval centered on the new entities to determine the local influence domain of the incremental knowledge units in the existing knowledge graph, and constructs a local relationship subgraph based on this local influence domain. Subsequently, context enhancement, deduplication detection, entity aggregation, relationship prediction, multi-dimensional conflict detection, and conflict resolution are performed within the local relationship subgraph, and the processed knowledge representation is written into the existing knowledge graph, thus narrowing the scope of the knowledge graph update from global reconstruction to local influence domains. Another approach uses a gated state update model to process the state memory corresponding to continuous inputs. This model separates the erasure and writing processes in a fixed-size cyclic state. It uses channel-level erasure gating to determine the content that needs to be cleared or decayed in the original state, and channel-level writing gating to determine the writing ratio of each state channel based on the current input representation and candidate states, so that the cyclic state is continuously updated within a fixed-size memory space.

[0004] However, dynamic graph update schemes based on influence domain identification primarily determine the entities, relations, and local relation subgraphs that need updating based on the influence range of incremental knowledge units within the graph structure. The processing results are used to complete the local writing of knowledge representations, failing to reflect the changes in the operational state of each link caused by semantic change events when processing links such as extraction rules, cleaning scripts, cache partitions, task queues, or code generation templates are jointly invoked by multiple target subgraphs. While gating state update models can control the proportion of candidate states written to the cyclic state memory through write gating, their write gating is based on the input representation containing overall link operational information. When the input representation is simultaneously affected by the current semantic change event, concurrent tasks in other subgraphs, and common load fluctuations, the written link state memory will contain a mixture of operational changes from these different sources, making it difficult to distinguish the portion caused by the current semantic change event. Therefore, accurately determining the link operational state change corresponding to the current semantic change event when a shared processing link is simultaneously affected by the current semantic change event, concurrent tasks in other subgraphs, and common load fluctuations becomes a problem that needs to be solved. Summary of the Invention

[0005] This application provides a dynamic graph data processing method based on multi-agent collaboration and a dual-element ontology, which can accurately determine the link operation state changes corresponding to the current semantic change event. This application provides the following technical solution: Firstly, this application provides a dynamic graph data processing method based on multi-agent cooperation and dual-element ontology, the method comprising: Acquire semantic change events, shared processing link identifiers, mixed running states of shared processing links, and pre-write link states generated by asynchronous updates of the dynamic graph by multiple agents, and form event link input objects; Based on the event chain input object, determine the state transition type corresponding to the semantic change event in the dual-element ontology, and determine the target subgraph region into which the state transition type falls; By combining the state transition type, the target subgraph region, and the shared processing link identifier, the ontology transition binding relationship between the state transition type and the shared processing link is determined, and the reuse pressure state is determined based on the mixed operation state of the shared processing link. The ontology conversion binding relationship and the multiplexing pressure state are used to generate an ontology conversion write bias, and the ontology conversion write bias is embedded into the gate value generation position of the state update model with channel-level write gating to generate the event-attributed write gating. The current candidate link state is generated based on the event link input object, and the proportion of channel-level writing from the current candidate link state to the link state before writing is controlled by the event attribution writing gating to obtain the event-constrained link state representation. Calculate the channel difference between the event constraint link state representation and the link state representation before writing, and obtain and output the event-attributed running state increment corresponding to the semantic change event.

[0006] In a specific feasible implementation, the step of acquiring semantic change events generated by multi-agent asynchronous updates of the dynamic graph, shared processing link identifiers, shared processing link hybrid operation states, and pre-write link state representations to form an event link input object includes: The original semantic change events are sorted according to timestamps, the currently pending semantic change events are read, and the changes corresponding to entity category expansion, relation edge addition, attribute level change and target subgraph structure change are parsed to form a semantic change event field vector. The change type and subgraph identifier of the semantic change event are matched with the preset link matching table to determine the shared processing link identifier. Based on the extraction rules, cleaning script, cache partition, task queue and code generation template corresponding fields in the matching table, a shared processing link identifier field vector is formed. Using the shared processing link identifier as a filtering condition, obtain the running status sampling records within a preset status window based on the generation time of the semantic change event, and form a shared processing link hybrid running status field vector. Obtain the link state representation corresponding to the shared processing link identifier and whose formation time is earlier than the generation time of the semantic change event. Determine the link state representation whose formation time is closest to the generation time as the pre-write link state representation. If no link state representation that meets the conditions is obtained, use the preset initial state representation as the pre-write link state representation. The semantic change event field vector, the shared processing link identifier field vector, the shared processing link hybrid operation status field vector, and the pre-write link status representation are arranged in a fixed field order to form the event link input object.

[0007] In a specific feasible implementation, determining the state transition type corresponding to the semantic change event in the dual-element ontology based on the event chain input object, and determining the target subgraph region into which the state transition type falls, includes: The event chain input object is mapped to an event chain representation, and based on the semantic element set in the dual-element ontology, the representation channel corresponding to the semantic change event field in the event chain representation is mapped to form a semantic change boundary; The semantic change boundary is matched with the semantic element identifier in the semantic element set to generate a set of state transition candidate types; The trigger field, starting state, and target subgraph constraint of each of the aforementioned state transition candidate types are matched with the state transition rule table in the bi-element ontology, and the state transition type is determined according to the rule priority. The target subgraph region is determined by matching the target subgraph constraint carried by the state transition type with the subgraph index table in the semantic element set.

[0008] In a specific implementation scheme, determining the ontology transformation binding relationship between the state transition type and the shared processing link by combining the state transition type, the target subgraph region, and the shared processing link identifier, and determining the multiplexing pressure state based on the mixed operation state of the shared processing link, includes: The state transition type and the shared processing link identifier are matched with a preset link matching table to determine the link pointing record; The target subgraph region and the shared processing link identifier are matched with the link function configuration table to determine the link function record; The link action record, the state transition type, and the target subgraph region are matched with the state writing qualification rule table to obtain the ontology transformation binding relationship that characterizes the state writing qualification between the state transition type and the shared processing link; Based on the call frequency, queue waiting time, failure rate, cache hit rate, load changes, and time slice changes in the hybrid operation state of the shared processing link, the reuse occupancy determination object is determined, and the reuse occupancy determination object is matched with the reuse pressure determination rule table to obtain the reuse pressure state.

[0009] In a specific implementation, the step of generating an ontology conversion write bias using the ontology conversion binding relationship and the multiplexing pressure state, and embedding the ontology conversion write bias into the gating value generation position of a state update model with channel-level write gating, to generate an event-attributed write gating, includes: Based on the state write qualification flag in the ontology conversion binding relationship, a write qualification limit object is generated, valid state write qualification flags are written to the corresponding channels, and invalid state write qualification flags are set to zero in the corresponding channels. By combining the write qualification restriction object and the multiplexing pressure state, a write impact restriction object is generated, retaining the write channel corresponding to the state transition type with state write qualification, and restricting the write channel that is not limited by the ontology transition binding relationship but is affected by the multiplexing pressure state; The write impact limiting object is mapped to an ontology conversion write bias that corresponds one-to-one with each write channel of the state update model; The original write signal generated at the gate value generation position by the channel-level write gate is obtained, and the body conversion write bias is embedded into the original write signal according to the channel correspondence, the gate value of each write channel is updated, and the event-attributed write gate is generated. The state update model is Gated DeltaNet-2, and the ontology conversion write bias only applies to the channel-level write gate.

[0010] In a specific implementation, the step of generating a current candidate link state based on the event link input object, and controlling the channel-level write ratio of the current candidate link state to the link state before writing through the event attribution write gating, to obtain an event-constrained link state representation, includes: The event link input object is mapped to an event link representation, and the event link representation input value is used to represent the generation layer to generate the current candidate link state, which includes multiple candidate write channels; Multiply the channel value of each candidate write channel in the current candidate link state with the corresponding channel-level gate value in the event-attributed write gate to form a candidate write constraint object; The channel value of each channel in the candidate write-limited object is limited to a preset ratio limit range to obtain the write ratio corresponding to each state channel; According to the write ratio corresponding to each state channel, the corresponding state channel in the pre-write link state representation is retained, and the corresponding candidate write channel in the current candidate link state is written into the pre-write link state representation to obtain the event-constrained link state representation.

[0011] In a specific implementation scheme, calculating the channel difference between the event constraint link state representation and the link state representation before writing, and obtaining and outputting the event attribution runtime state increment corresponding to the semantic change event, includes: The difference calculation is performed on the state channels with the same channel meaning in the event-constrained link state representation and the pre-write link state representation to form a link state difference object; According to the preset channel range, call changes, queue changes, failure changes, cache changes, load changes, and link state memory changes are determined from the link state difference objects; The channel difference values ​​corresponding to the call change, queue change, failure change, cache change, load change, and link state memory change are written into the corresponding incremental channels in channel order to form and output the event-assigned running state increment.

[0012] Secondly, this application provides a dynamic map data processing system based on multi-agent cooperation and dual-element ontology, employing the following technical solution: A dynamic map data processing system based on multi-agent cooperation and dual-element ontology, comprising: The event link construction module is used to acquire semantic change events, shared processing link identifiers, shared processing link mixed operation status and link status representation before writing generated by multi-agent asynchronous updates of dynamic graph, and form event link input objects; The ontology transformation and recognition module is used to determine the state transformation type corresponding to the semantic change event in the dual-element ontology based on the event link input object, and to determine the target subgraph region into which the state transformation type falls. The link constraint determination module is used to combine the state transition type, the target subgraph region, and the shared processing link identifier to determine the ontology transformation binding relationship between the state transition type and the shared processing link, and to determine the reuse pressure state based on the mixed operation state of the shared processing link. The write gate generation module is used to generate an ontology conversion write bias using the ontology conversion binding relationship and the multiplexing pressure state, and to embed the ontology conversion write bias into the gate value generation position of the state update model with channel-level write gate, and to generate an event belonging to the write gate. The link state update module is used to generate the current candidate link state based on the event link input object, and control the channel-level write ratio of the current candidate link state to the link state before writing through the event attribution write gate to obtain the event-constrained link state representation; The state increment output module is used to calculate the channel difference between the event constraint link state representation and the link state representation before writing, and to obtain and output the event-attributed running state increment corresponding to the semantic change event.

[0013] Thirdly, this application provides an electronic device, the device including a processor and a memory; the memory stores a program, the program being loaded and executed by the processor to implement a dynamic map data processing method based on multi-agent collaboration and dual-element ontology as described in the first aspect.

[0014] Fourthly, this application provides a computer-readable storage medium storing a program that, when executed by a processor, is used to implement a dynamic map data processing method based on multi-agent collaboration and dual-element ontology as described in the first aspect.

[0015] By acquiring semantic change events, shared processing link identifiers, the mixed operating state of shared processing links, and the link state representation before writing, an event link input object is formed. A dual-element ontology is used to determine the state transition type and its target subgraph region corresponding to the semantic change event, thereby determining the ontology transformation binding relationship between the state transition type and the shared processing link, as well as the reuse pressure state of the shared processing link. Based on this, an ontology transformation write bias is generated and embedded into a state update model with channel-level write gating to form an event-attributed write gating. This event-attributed write gating controls the proportion of channel-level writes from the current candidate link state to the link state representation before writing, resulting in an event-constrained link state representation. The channel difference between the event-constrained link state representation and the link state representation before writing forms the event-attributed operating state increment. Thus, the correspondence between the state transition type, target subgraph region, and shared processing link can be transformed into channel-level write constraints during the state writing stage. Combined with the reuse pressure state, differentiated writing is performed on the candidate link states corresponding to the mixed operating state, ensuring a clearer correspondence between the resulting link state changes and the current semantic change event, thereby improving the accuracy of the event-attributed operating state increment.

[0016] The above description is only an overview of the technical solution of this application. In order to better understand the technical means of this application and to implement it in accordance with the contents of the specification, the preferred embodiments of this application are described in detail below with reference to the accompanying drawings. Attached Figure Description

[0017] Figure 1 This is a flowchart illustrating the dynamic map data processing method based on multi-agent collaboration and dual-element ontology in this application embodiment.

[0018] Figure 2 This is a schematic diagram of the overall process of the dynamic map data processing method based on multi-agent collaboration and dual-element ontology in the embodiments of this application.

[0019] Figure 3 This is a graph showing the hybrid write pollution rate under shared link load in this embodiment of the application.

[0020] Figure 4 This is the ablation heat map of the target sub-graph scene in the embodiments of this application.

[0021] Figure 5 This is an index loss diagram of the ablation variant relative to the complete model in the embodiments of this application.

[0022] Figure 6 This is a structural block diagram of the dynamic map data processing system based on multi-agent collaboration and dual-element ontology in the embodiments of this application.

[0023] Figure 7This is a block diagram of an electronic device based on dynamic graph data processing using multi-agent collaboration and dual-element ontology, as described in this application. Detailed Implementation

[0024] The specific embodiments of this application will be described in further detail below with reference to the accompanying drawings and examples. The following examples are used to illustrate this application, but are not intended to limit the scope of this application.

[0025] Reference Figure 1 This is a flowchart illustrating a dynamic map data processing method based on multi-agent collaboration and dual-element ontology provided in an embodiment of this application. The method includes at least the following steps: Step S1: Obtain the semantic change events, shared processing link identifiers, shared processing link mixed operation status and link status representation before writing generated by the asynchronous update of the dynamic graph by multiple agents, and form an event link input object.

[0026] Step S1 uses the currently pending semantic change event as a unified index to determine the semantic change content, the shared processing link corresponding to the semantic change event, the mixed operation state of the shared processing link when the semantic change event is generated, and the link state before the semantic change event is written. The above content is organized into an event link input object so that the semantic change content, the link ownership content, the link operation content, and the state content before writing have consistent event boundaries and link boundaries.

[0027] Specifically, the original semantic change events are sorted according to timestamps, the currently pending semantic change events are read, and the changes corresponding to entity category expansion, relation edge addition, attribute level change and target subgraph structure change are parsed to form a semantic change event field vector.

[0028] The raw semantic change events generated by asynchronous updates of the dynamic graph by multiple agents are organized into a sequence of raw semantic change events according to timestamps: ; in, This represents the original semantic change event sequence; This represents the event index in the original semantic change event sequence; This represents the total number of original semantic change events; Indicates the first The time of occurrence of each original semantic change event; Indicates the first A primitive semantic change event.

[0029] According to the time of creation The original semantic change event sequence is sorted in ascending order, and the currently pending semantic change event is read from the sorted original semantic change event sequence. and the time of its creation ,in, This represents the index of the event currently pending. It also represents the semantic change event currently pending. Perform field parsing to form a semantic change event field vector: ;in, This represents a vector of semantic change event fields.

[0030] Fields to Used to express entity category expansion, it includes, in sequence, the new entity category identifier, the parent entity category identifier, the category hierarchy depth, the change in the number of category attributes, the change in the number of entities associated with the category, the category trigger time slice, the subgraph identifier to which the category belongs, and the category change type.

[0031] Fields to Used to express the addition of a relation edge, it includes, in order, the source entity category, the target entity category, the relation type, the relation direction, the relation trigger time slice, the change in the number of relation edges, the identifier of the subgraph to which the relation belongs, and the relation change type.

[0032] Fields to Used to express changes in attribute hierarchy, it includes, in order: attribute identifier, parent attribute identifier, change in attribute hierarchy depth, attribute value type, number of affected entities, attribute trigger time slice, attribute to subgraph identifier, and attribute change type.

[0033] Fields to The structure of the target subgraph is expressed by the following elements: target subgraph identifier, change in the number of nodes, change in the number of edges, change in the number of connected components, change in the number of boundary nodes, change in the number of edges across the subgraph, subgraph trigger time slice, and subgraph change type.

[0034] When determining the shared processing link identifier, the change type and subgraph identifier of the semantic change event are matched with the preset link matching table to determine the shared processing link identifier. Based on the extraction rules, cleaning scripts, cache partitions, task queues and code generation templates in the matching table entries, a shared processing link identifier field vector is formed.

[0035] The shared processing link set is represented as: ; in, This represents the set of shared processing links for asynchronous updates of the dynamic graph by multiple agents; Indicates a shared processing link index; Indicates the total number of shared processing links; Indicates the first A shared processing link identifier.

[0036] Preset link matching table The semantic change event's change type, subgraph identifier, extraction rule entry point, cleaning script entry point, cache partition entry point, task queue entry point, code generation template entry point, and shared processing link identifier are pre-recorded. The category change type, relationship change type, attribute change type, subgraph change type, and subgraph identifier from the semantic change event field vector are then matched against a pre-defined link matching table. The entries in the table are matched to obtain the shared processing link identifier corresponding to the semantic change event to be processed. .

[0037] Read the extraction rules, cleaning scripts, cache partitions, task queues, and code generation templates from the matched table entries to form a vector of shared processing link identifier fields: ; in, Represents a vector of shared processing link identifier fields; fields to The fields represent the extraction rule type, extraction rule version, and extraction rule trigger field, respectively. to The fields represent the cleaning script type, cleaning script version, and cleaning script input structure, respectively. to The fields represent, in order, the cache partition identifier, the cache partition capacity level, and the cache partition hit status; to The fields represent the task queue identifier, task queue priority, and task queue waiting length, respectively. to These represent, in order, the code generation template type, the code generation template version, the executable node type, and the link enable flag.

[0038] When acquiring the mixed operation status of the shared processing link, the shared processing link identifier is used as the filtering condition to acquire the operation status sampling records within a preset status window based on the generation time of the semantic change event, forming a shared processing link mixed operation status field vector.

[0039] The shared processing link running status sampling sequence is represented as follows: ; in, This represents a sampled sequence indicating the running status of the shared processing link; Indicates the running status sampling index; Indicates the total number of samples taken for the running status; Indicates the first The sampling time for each running status sample; Indicates the first One operational status sampling record; Indicates the first The shared processing link identifier corresponding to each running status sampling record.

[0040] by As a filtering criterion, the running status sampling records corresponding to the current shared processing link are retained, and then the generation time of the semantic change event to be processed is used. Using time as the reference, according to the preset state window length Select time range The internal running status sampling records form a shared processing link hybrid running status field vector: ; in, This represents a vector of fields indicating the mixed operational status of the shared processing link.

[0041] Fields to The fields represent, in order: the number of calls within the window, the number of calls in the previous window, the number of calls in the current agent, and the number of calls across subgraphs; to The fields represent, in order: latest queue waiting time, average queue waiting time within the window, maximum queue waiting time within the window, and number of tasks pending processing. to The fields represent, in order: number of failed calls, total number of calls, failure rate, and number of consecutive failures. to These represent, in order, the number of cache hits, the number of cache reads, the cache hit rate, and the number of cache misses; (fields) to The fields represent the current load utilization, the load utilization of the previous window, the load change value, and the number of load fluctuations, respectively. to These represent the current time slice index, window start time, window end time, and number of window samples, respectively.

[0042] The shared processing link hybrid operation status field vector is used to express the overall operation status of the shared processing link when the current pending semantic change event occurs. At this stage, the current pending semantic change event, other subgraph concurrent tasks, and common load fluctuations are not assigned to different statuses.

[0043] When obtaining the link state representation before writing, obtain the link state representation that corresponds to the shared processing link identifier and whose formation time is earlier than the semantic change event generation time, and determine the link state representation whose formation time is closest to the generation time as the link state representation before writing; if no link state representation that meets the conditions is obtained, the preset initial state representation is used as the link state representation before writing.

[0044] The shared processing link state representation sequence is represented as follows: ; in, This indicates a sequence of shared processing link states; Indicates the shared processing link status index; The shared processing link status indicates the total number; Indicates the first The formation time of the shared processing link state representation; Indicates the first A shared processing link status representation; Indicates the first Each shared processing link status indicates the corresponding shared processing link identifier.

[0045] by and As a filtering criterion, the link state representations formed before the current semantic change event occur in the current shared processing link are retained, and the one with the closest formation time is selected from them. The link state representation is used as the link state representation before writing: ; in, This indicates the link state before the current semantic change event is written; field to Indicates invoking the change memory channel; field to Represents queue change memory channel; field to Indicates a failure change memory channel; field to Indicates the cache change memory channel; field to Indicates a memory channel for load changes; field to This indicates the link state memory channel.

[0046] The shared processing link state representation sequence does not contain a sequence that satisfies... and When representing the link state, a preset initial state representation is used as... The number of channels and the meaning of each channel in the preset initial state are consistent with the link state before writing.

[0047] When forming the event chain input object, the semantic change event field vector, the shared processing chain identifier field vector, the shared processing chain mixed running status field vector, and the pre-write chain status representation are arranged in a fixed field order: ; in, This represents the event chain input object corresponding to the semantic change event currently pending processing; This is a 32-dimensional semantic change event field vector; A 16-dimensional shared processing link identifier field vector; This is a 24-dimensional shared processing link hybrid operation status field vector; Write the 128-dimensional front-link state representation. Therefore, the event link input object... The total dimensions are 200.

[0048] The event link input object uses the currently pending semantic change event as a unified index, and organizes the semantic change content, shared processing link affiliation, shared processing link running status, and pre-write state into the same input vector, so that the data entering the state update model has consistent event boundaries and link boundaries.

[0049] Step S2: Based on the event chain input object, determine the state transition type corresponding to the semantic change event in the dual-element ontology, and determine the target subgraph region into which the state transition type falls.

[0050] Step S2 uses a dual-element ontology to perform semantic boundary recognition and state transition rule matching on the current semantic change event. First, it determines the state transition type caused by the semantic change event, and then determines the corresponding target subgraph region based on the target subgraph constraints carried by the state transition type, so that the semantic change content is converted into a processing result with a clear state change direction and graph scope.

[0051] Specifically, the event chain input object is mapped to the event chain representation, and based on the semantic element set in the bi-element ontology, the representation channels corresponding to the semantic change event fields in the event chain representation are mapped to form semantic change boundaries; the semantic change boundaries are matched with the semantic element identifiers in the semantic element set to generate a set of state transition candidate types; the trigger fields, starting states, and target subgraph constraints of each state transition candidate type are matched with the state transition rule table in the bi-element ontology, and the state transition type is determined according to the rule priority; the target subgraph constraints carried by the state transition type are matched with the subgraph index table in the semantic element set to determine the target subgraph region.

[0052] When generating the event chain representation, the event chain input object obtained in step S1 is denoted as: ; in, This represents the event chain input object corresponding to the semantic change event currently pending processing; Represents a vector of semantic change event fields; Represents a vector of shared processing link identifier fields; A vector of fields representing the mixed operational status of the shared processing link; This indicates the link state representation before writing.

[0053] The event chain input object is fed into a pre-trained input mapping layer, and the event chain representation is generated according to the following formula: ; in, Indicates the event chain representation; Indicates the fully connected weights of the input mapping layer; Indicates the bias of the input mapping layer; This represents the SiLU nonlinear processing function.

[0054] The input mapping layer consists of 128 neurons. Each neuron receives a 200-dimensional field from the event chain input object and generates a mapping value based on the corresponding fully connected weights and biases. After SiLU nonlinear processing, a 128-dimensional event chain representation is obtained. ; in, to These represent the 128 representation channels of the event chain representation. The event chain representation maps semantic change events, shared processing chain identifiers, shared processing chain mixed running states, and pre-write chain state representations to a unified representation space, facilitating the identification of semantic change boundaries and state transition relationships within the same channel space for dual-element ontologies.

[0055] The dual-element ontology comprises a set of semantic elements and a set of dynamic elements. The set of semantic elements includes semantic elements corresponding to entity categories, relation edges, attribute levels, and target subgraph structures, used to describe the knowledge structure and its scope of application in the dynamic graph. The set of dynamic elements includes state transition triggering conditions, state transition rules, target subgraph landing point rules, and shared processing link influence flags, used to describe the state change patterns and link influence relationships corresponding to changes in semantic elements.

[0056] The dual-element ontology mapping layer maps the representation channels corresponding to semantic change event fields in the event chain representation based on the entity category identifier, relation edge identifier, attribute level identifier, and target subgraph identifier in the semantic element set, thus forming semantic change boundaries: ; in, This indicates the semantic change boundary corresponding to the semantic change event currently pending processing; to Indicates the entity category extended boundary field; to This indicates that a new boundary field has been added to the relation edge; to This field represents the boundary of attribute hierarchy changes; to This field represents the boundary field for changes in the target subgraph structure.

[0057] Semantic change boundaries are used to distinguish whether the current semantic change event specifically affects the entity category, relation edge, attribute level, or target subgraph structure, thus avoiding treating different types of semantic changes as the same state transition.

[0058] A set of candidate state transition types is formed based on semantic change boundaries: ; in, Represents the set of candidate state transition types; Indicates the first One state transition candidate type; This indicates the number of candidate state transition types.

[0059] The set of state transition candidate types is formed by matching semantic change boundaries with semantic element identifiers in the semantic element set. When the entity category extension boundary field matches an entity category hierarchical change item, an entity category state transition candidate type is generated; when the relation edge addition boundary field matches a relation edge topology change item, a relation edge state transition candidate type is generated; when the attribute hierarchy change boundary field matches an attribute hierarchy change item, an attribute hierarchy state transition candidate type is generated; and when the target subgraph structure change boundary field matches a target subgraph structure change item, a target subgraph state transition candidate type is generated.

[0060] Input the set of candidate state transition types into the state transition rule table corresponding to the set of dynamic elements. The state transition rule table includes candidate type identifier, trigger field, starting state, target state, target subgraph constraints, shared processing link influence flag, and rule priority.

[0061] For each state transition candidate type in the set of state transition candidate types, its trigger field, starting state, and target subgraph constraint are matched against the corresponding fields in the state transition rule table. State transition candidate types with the same trigger field, starting state, and target subgraph constraint are retained. When multiple state transition candidate types meet the matching conditions, the state transition type corresponding to the current semantic change event is determined according to the rule priority. .

[0062] State transition types are represented by 32-dimensional fields, which include state transition category, triggering semantic element, starting state identifier, target state identifier, target subgraph constraints, shared processing link impact flag, rule priority, and state transition effective time slice. The state transition type expresses both the direction of state change caused by the current semantic change event and carries information about the target subgraph range and the impact of shared processing links.

[0063] When determining the target subgraph region, the subgraph index table in the semantic element set is read. The subgraph index table includes the target subgraph identifier, node range, relation edge range, attribute range, boundary node range, and cross-subgraph relation range.

[0064] Transform state type The target subgraph constraints are matched against the corresponding fields in the subgraph index table to obtain the target subgraph region. ; in, Indicates the target sub-map region; to This indicates the target subgraph identifier field; to Indicates a field representing the range of nodes; to Fields representing the scope of relation edges; to This field represents the attribute range and boundary node range.

[0065] In one specific implementation, the state transition type and the target subgraph region are arranged in a fixed field order to form a target subgraph transition object: ; in, Indicates the target subgraph transformation object; Indicates a 32-dimensional state transition type; This represents a 32-dimensional target subgraph region. The total dimension of the target subgraph transformation object is 64 dimensions, used to uniformly express the state transition content corresponding to the current semantic change event and its area of ​​influence in the dynamic graph.

[0066] Step S3: Combine the state transition type, target subgraph region, and shared processing link identifier to determine the ontology transition binding relationship between the state transition type and the shared processing link, and determine the reuse pressure state based on the mixed operation state of the shared processing link.

[0067] Step S3 is used to form write constraints from two aspects: state writing eligibility and link reuse operation status. Among them, ontology transformation binding relationship is used to express whether the current state transformation type is eligible to write state to the corresponding shared processing link, and reuse pressure state is used to express whether the shared processing link is also affected by other subgraph tasks, common load fluctuations, queue load and cache load when the current semantic change event occurs.

[0068] Specifically, the state transition type and shared processing link identifier are matched with a preset link matching table to determine the link pointing record; the target subgraph region and shared processing link identifier are matched with a link function configuration table to determine the link function record; the link function record, state transition type, and target subgraph region are matched with a state writing qualification rule table to obtain the ontology conversion binding relationship representing the state writing qualification between the state transition type and the shared processing link; based on the call frequency, queue waiting time, failure rate, cache hit rate, load change, and time slice change in the mixed operation state of the shared processing link, the reuse occupancy judgment object is determined, and the reuse occupancy judgment object is matched with the reuse pressure judgment rule table to obtain the reuse pressure state.

[0069] The target subgraph transformation object obtained in step S2 is represented as follows: in, This represents the target subgraph transformation object corresponding to the semantic change event currently pending processing; This represents the index of the semantic change events currently pending processing; Indicates the state transition type; This represents the target sub-map region.

[0070] Shared processing link identifier is denoted as This represents the identifier of the shared processing link that matches the currently pending semantic change event. The mixed operation state of the shared processing link is represented as follows: ; in, This represents a vector of mixed runtime status fields corresponding to the shared processing link for the currently pending semantic change event. The target subgraph transformation object, the shared processing link identifier, and the mixed runtime status of the shared processing link are used together to determine the eligibility for state writing and the reuse runtime scenario.

[0071] When determining the link pointing record, the state transition type is read from the target subgraph transition object, and a preset link matching table is also read. The preset link matching table includes a state transition type identifier, a target subgraph identifier, a shared processing link identifier, a link entry type, and a link trigger field.

[0072] Match the state transition type identifier carried by the state transition type with the state transition type identifier in the preset link matching table, and at the same time, share the processing link identifier. The shared processing link identifier is matched against the pre-defined link matching table. Entries where both the state transition type identifier and the shared processing link identifier match are identified as link pointing records, and link pointing determination objects are formed based on these records. ; in, Indicates the link points to the object being determined; to These represent the state transition type identifier, the target subgraph identifier, and the shared processing link identifier, respectively. Indicates a valid link trigger flag; to These represent the hit flags for the extraction rule entry point, the cleaning script entry point, the cache partition entry point, the task queue entry point, and the code generation template entry point, respectively. to These represent the link ingress type, link ingress version, and link ingress priority, respectively. to These represent the trigger field identifier, trigger field source, and trigger field time slice, respectively. This indicates that the link is valid.

[0073] The link pointing determination object is used to confirm the shared processing link and its link entry point that the current state transition type actually points to, avoiding the need to determine the state write object solely based on the semantic change type.

[0074] When determining the link action record, the target subgraph region is read from the target subgraph transformation object, and the link action configuration table is also read. The link action configuration table is formed by the dual-element ontology configuration and the shared processing link configuration, including the target subgraph identifier, node range, relation edge range, attribute range, shared processing link identifier, and link action type.

[0075] The shared processing link identifier field in the link pointing determination object is matched with the shared processing link identifier in the link action configuration table. The target subgraph identifier, node range, relation edge range, and attribute range in the target subgraph region are then matched with the corresponding fields in the link action configuration table. Table entries with matching shared processing link identifiers and matching target subgraph region fields are identified as link action records, and link action constraint objects are formed based on these records. ; in, Indicates the object whose function is limited by the link; to These represent the extraction rule identifier, extraction input field, extraction output field, and data extraction validity flag, respectively. to These represent the cleaning script identifier, cleaning input fields, cleaning output fields, and a valid indicator of the data cleaning effect, respectively. to These represent the cache partition identifier, the cache hosting field, and the valid flag for the cache hosting function, respectively. to These represent the task queue identifier, the queue carrying field, and the valid flag for the queue carrying function, respectively. and These represent the code generation template identifier and the valid code generation function indicator, respectively.

[0076] The link action limit object is used to determine which type of processing, such as data extraction, data cleaning, cache hosting, queue hosting, or code generation, the current state transition actually affects within the target subgraph region.

[0077] When forming ontology transformation binding relationships, the link action constraint object is matched with the state write qualification rule table. The state write qualification rule table includes link action type, state transformation type, target subgraph region constraint, and state write qualification flag.

[0078] The link action type, state transition type, and target subgraph region in the link action constraint object are compared with the corresponding fields in the state writing qualification rule table. If the link action type, state transition type, and target subgraph region constraints are consistent, the corresponding state writing qualification flag is written into the ontology transition binding relationship. ; in, This indicates the ontology conversion binding relationship.

[0079] Fields to Used to express state transition type identifier, starting state identifier, target state identifier, and state transition type binding flag; field to Used to express trigger semantic element identifier, trigger dynamic element identifier, rule priority, and status writing qualification flag.

[0080] Fields to Used to express target subgraph identifier, node range hit flag, relation edge range hit flag, attribute range hit flag, boundary node range hit flag, cross-subgraph relation range hit flag, target subgraph region binding flag, and target subgraph region constraint flag.

[0081] Fields to It is used to express the shared processing link identifier, extraction rule writing qualification flag, cleaning script writing qualification flag, cache partition writing qualification flag, task queue writing qualification flag, code generation template writing qualification flag, link entry writing qualification flag, and shared processing link writing qualification flag.

[0082] Fields to This is used to express the binding flags for data extraction, data cleaning, cache hosting, queue hosting, code generation, link type, state transition, and ontology transformation.

[0083] Ontology transformation binding relationship is used to express whether there is state writing qualification between state transformation type and shared processing link, so that the current semantic change event can obtain the corresponding link state channel writing qualification only when the state transformation type, target subgraph region and link action are all matched.

[0084] When determining the object to be used for reuse occupancy, the system reads the number of cross-subgraph calls, total number of calls, average window queue wait time, failure rate, cache hit rate, load change value, and time slice change value from the mixed operation status of the shared processing link, and also reads the reuse occupancy determination rule table.

[0085] The reuse occupancy determination rule table includes call frequency threshold, queue wait time threshold, failure rate threshold, cache hit rate threshold, load change threshold, time slice change threshold, and reuse occupancy trigger threshold. Each field in the reuse occupancy determination object is determined according to the following formula: ; in, Indicates the first in the reuse occupancy determination object The values ​​that can be obtained from each field; This indicates the field index of the object used for reuse determination; This indicates an indicator function; the value is 1 if the condition within the parentheses is met, and 0 if the condition is not met. Indicates the number of calls across subgraphs; Indicates the total number of calls; This indicates a preset non-zero constant, used to avoid a denominator of 0.

[0086] This indicates the average queue waiting time within the window; Indicates the relationship with the first Each field corresponds to a queue waiting time threshold; Indicates the failure rate; Indicates the relationship with the first The failure rate thresholds corresponding to each field; Indicates cache hit rate; Indicates the relationship with the first The cache hit rate thresholds for each field.

[0087] This represents the difference when the cache hit rate is lower than the cache hit rate threshold; it is 0 when the cache hit rate is not lower than the cache hit rate threshold. Indicates the load change value; This represents the absolute value of the load change. Indicates the relationship with the first The load change thresholds corresponding to each field; Indicates the change value over time; Indicates the relationship with the first The time slice change thresholds corresponding to each field; Indicates the relationship with the first The reuse threshold for each field.

[0088] The queue wait time threshold, failure rate threshold, cache hit rate threshold, load change threshold, and time slice change threshold are all pre-set positive values. The ratio of call counts, queue wait time, failure rate, cache hit rate difference, load change, and time slice change are all dimensionless decision quantities. Through a unified decision metric, other subgraph task calls, queue load, failure status, cache status, common load fluctuations, and time slice changes are no longer directly used as the basis for writing the unified status.

[0089] The object for determining reuse and occupancy is represented as: ; in, Indicates the object to be used for reuse determination; to Indicates the fields occupied by other subgraph tasks; to This indicates the common load fluctuation field; to This indicates the field that the queue carries. to This indicates the field used by the cache.

[0090] When determining the reuse pressure status, the reuse occupancy determination object is matched with the reuse pressure determination rule table. The reuse pressure determination rule table includes the occupancy conditions of other subgraph tasks, the common load fluctuation conditions, the queue capacity occupancy conditions, the cache capacity occupancy conditions, and the reuse pressure status flag.

[0091] Each field in the reuse occupancy determination object is compared with the corresponding condition in the reuse pressure determination rule table. The reuse pressure status flag that meets the corresponding condition is written into the reuse pressure status: ; in, Indicates a reused pressure-bearing state; to Indicates the pressure field for other subgraph tasks; to This indicates the field representing the pressure of public load fluctuations; to This indicates the queue carries the pressure field; to This indicates the cache load capacity field. The reuse load capacity status is used to express whether the shared processing link is simultaneously affected by other subgraph tasks, common load fluctuations, queue load, and cache load when the current pending semantic change event occurs.

[0092] In one specific implementation, the ontology conversion binding relationship and the reused stress state are arranged in a fixed field order to form a link writing constraint object: ;in, This indicates that the link is written to the constraint object; This represents the 32-dimensional ontology transformation binding relationship; This indicates a 32-dimensional multiplexing pressure state, therefore the total dimension of the link write constraint object is 64 dimensions.

[0093] The link write constraint object does not belong to the event-owned running state increment, nor does it directly change the structure of the state update model. Instead, it organizes the ontology transformation binding relationship between the state transformation type and the shared processing link, as well as the current reuse pressure state of the shared processing link, into the same constraint object, so that the ontology transformation write bias enters the write gate of the state update model based on the same constraint object.

[0094] Step S4: Generate the ontology conversion write bias using the ontology conversion binding relationship and the reuse pressure state, and embed the ontology conversion write bias into the gate value generation position of the state update model with channel-level write gating, and generate the event belonging to the write gating.

[0095] Step S4 converts the state writing eligibility corresponding to the semantic change event and the current multiplexing impact on the shared processing link into channel-level write constraints, and introduces these write constraints when the state update model forms the write gating value. This process does not change the generated content of the candidate link state, but adjusts the write ratio of each write channel by event attribution before the candidate link state is actually written into the link state memory.

[0096] Specifically, a write qualification constraint object is generated based on the state write qualification flag in the ontology conversion binding relationship. Valid state write qualification flags are written to the corresponding channels, and channels corresponding to invalid state write qualification flags are set to zero. A write impact constraint object is generated by combining the write qualification constraint object and the reuse pressure state. The write channels corresponding to the state conversion type with state write qualification are retained, and the write channels not constrained by the ontology conversion binding relationship but affected by the reuse pressure state are constrained. The write impact constraint object is mapped to the ontology conversion write bias amount corresponding one-to-one with each write channel of the state update model. The original write signal formed by the channel-level write gating at the gating value generation position is obtained, and the ontology conversion write bias amount is embedded into the original write signal according to the channel correspondence, the gating value of each write channel is updated, and the event-attributed write gating is generated.

[0097] The link write constraint object obtained in step S3 is represented as follows: ;in, This represents the link write constraint object corresponding to the semantic change event currently pending processing; This represents the index of the semantic change events currently pending processing; Indicates the ontology conversion binding relationship; This indicates a reusable pressure-bearing state.

[0098] The ontology conversion binding relationship is represented as follows: ;in, to Used to express the eligibility for state writing between state transition types and shared processing links.

[0099] The reused pressure condition is represented as follows: ;in, to This is used to express the impact of other subgraph tasks, common load fluctuations, queue load, and cache load on the shared processing link within the current time slice.

[0100] The link write constraint object serves as the input to the ontology transformation write bias generation process and is not directly written to the link state representation before writing.

[0101] When generating write eligibility objects, the ontology transformation binding relationship is read from the link write constraint object, and the write eligibility corresponding to each type of object is determined based on the state write eligibility flag in the ontology transformation binding relationship, resulting in: ;in, This indicates that the qualification object should be written to. to The state transition type is written to the eligibility field; to This indicates that the target subgraph region is written to the qualification field; to This indicates that the shared processing link is written to the qualification field; to The link function is written into the qualification field.

[0102] When the state write eligibility flag in the ontology conversion binding relationship is valid, the corresponding eligibility field is written to the corresponding channel of the write eligibility qualifying object; when the state write eligibility flag is invalid, the corresponding channel is set to zero. Thus, the write eligibility qualifying object expresses the write eligibility of the current semantic change event for different state channels in the shared processing link.

[0103] Furthermore, the multiplexing stress state is read from the link write constraint object, and a write impact constraint object is generated by combining it with the write eligibility constraint object: ;in, This indicates that the write operation affects the specified object.

[0104] Fields to Indicates the field affected by the state transition type that is eligible for state writing; field to Indicates the target subgraph region's influence field that is eligible for state writes; field to This field represents the shared processing link that is eligible for state writing; to This field represents the influence of a link that is eligible to write state information.

[0105] Fields to This field indicates the impact of pressure on other subgraph tasks; field to This field indicates the impact of public load fluctuations on pressure. to This field indicates the impact of queue load on pressure. to This indicates the field that is affected by the load on the cache.

[0106] When an ontology transformation binding relationship indicates that the current semantic change event is eligible for state writing, the write impact limiting object retains the write channel markers corresponding to the state transformation type, target subgraph region, shared processing link, and link action. When the multiplexing pressure state indicates that the shared processing link is in a multiplexing mixed state, the write impact limiting object marks the write channels not limited by the ontology transformation binding relationship. Thus, the write impact limiting object simultaneously assumes write eligibility and multiplexing impact, used to limit the writable impact range of the current semantic change event in the mixed operation state of the shared processing link.

[0107] The ontology conversion write bias generation layer receives the write-affected bounded object and generates the ontology conversion write bias: ;in, Indicates the offset amount written during the body conversion; to These represent the bias values ​​that correspond one-to-one with the 128 write channels of the state update model.

[0108] The ontology transformation write bias generation layer comprises 128 neurons, each fully connected to a 64-dimensional field of the write influence constraint object, and configured with weights, biases, and sigmoid nonlinear units. The write channel markers retained in the write influence constraint object cause the corresponding neurons to generate bias signals that allow the current candidate link state to be written; the write channel markers constrained in the write influence constraint object cause the corresponding neurons to generate bias signals that reduce the proportion of the current candidate link state to be written. The ontology transformation write bias is only used as an internal bias of the native write gating of the state update model, and is not used as an external scoring result or as an output filtering result.

[0109] In one specific implementation, the state update model adopts the Gated DeltaNet-2 architecture. The Gated DeltaNet-2 architecture includes a fixed-size cyclic state, channel-level erase gating, and channel-level write gating. The fixed-size cyclic state is used to store the state memory of the shared processing links during successive semantic change events; the channel-level erase gating is used to control the reading and clearing of old state associations in the link state representation before writing; and the channel-level write gating is used to control the proportion of the current candidate link state written to the link state representation before writing.

[0110] Obtain the raw write signal generated at the gate value generation location by the native write gate of Gated DeltaNet-2: ;in, Indicates the original write signal; to This represents 128 channel-level raw write values.

[0111] The native write gating layer consists of 128 gating neurons. Each gating neuron receives the gating input field, gating weight, and gating bias of the corresponding channel in the event link representation, and forms the original write value of the corresponding channel at the gating value generation position. The original write signal is used to express the native determination of the write ratio of the current candidate link state by the state update model when the write bias is not embedded in the ontology transformation.

[0112] Based on the one-to-one correspondence of the write channels, the body conversion write bias is embedded into the original write signal. The first... The bias value only applies to the first bias value in the original written signal. One write channel, of which To write the channel index, and .

[0113] The gating values ​​of each write channel are updated based on the original write signal after the embedded ontology conversion write bias, forming an event-attributed write gating: ;in, Indicate event attribution by writing to the gating; to This indicates the gating value for the 128 channel-level events.

[0114] For write channels that correspond to ontology conversion binding relationships, the event-attributed write gate maintains the writable ratio of the current candidate link state; for write channels that are not limited by ontology conversion binding relationships and are affected by multiplexing pressure state, the event-attributed write gate reduces or restricts the write ratio of the current candidate link state.

[0115] The ontology conversion write bias is only embedded in the channel-level write gate of Gated DeltaNet-2. The erase gate maintains the original old state association reading and clearing method, the key representation generation process maintains the original key representation formation method, and the current candidate link state generation process maintains the original value representation formation method. The ontology conversion write bias does not enter the erase gate, the key representation generation process, or the current candidate link state generation process.

[0116] Therefore, the event attribution write gate inherits the state write position of the native write gate, and introduces channel constraints formed by ontology conversion binding relationship and reuse pressure state at the same gate value generation position, so that the write ratio of the current candidate link state is simultaneously limited by the current semantic change event write qualification and the shared processing link reuse operation status.

[0117] During the model training phase, the weights, biases, short convolutional kernel parameters, and gate weight parameters in the input mapping layer, bi-element ontology mapping layer, link write constraint layer, ontology transformation write bias generation layer, query representation generation layer, key representation generation layer, value representation generation layer, and native write gate layer are all pre-trained using historical event link samples.

[0118] The historical event link sample includes historical semantic change events, historical shared processing link identifiers, historical shared processing link mixed operation status, historical link status representation before writing, historical ontology conversion binding relationship, historical reuse under pressure status, historical event constraint link status representation, and historical event ownership operation status increment.

[0119] During training, historical event link input objects are used as model inputs, while the state representations of historical event constraint links and the increments of historical event-assigned running states are used as supervision targets. This ensures that channels eligible for state writing maintain a high write rate, while reducing the write rate of channels not limited by ontology transformation binding relationships and affected by reuse pressure states. After training, the model parameters are fixed, and during the dynamic graph execution phase, the inference process from event link input objects to event-assigned running state increments is executed according to these fixed parameters.

[0120] Step S5: Generate the current candidate link state based on the event link input object, and control the proportion of the current candidate link state to be written to the channel level of the link state before writing through the event attribution write gating to obtain the event-constrained link state representation.

[0121] Step S5 first converts the event link input object into candidate content to be written to the shared processing link state memory within the current time slice, and then uses event-attributed write gating to independently limit each candidate write channel. The candidate content after channel-level gating is converted into the corresponding write ratio, and together with the original state retained in the link state representation before writing, forms the event-constrained link state representation.

[0122] Specifically, the event link input object is mapped to the event link representation, and the event link representation input value is used to generate the generation layer to generate the current candidate link state, which includes multiple candidate write channels. The channel value of each candidate write channel in the current candidate link state is multiplied by the corresponding channel-level gate value in the event-attributed write gate to form a candidate write constraint object. The channel value of each channel in the candidate write constraint object is constrained within a preset ratio range to obtain the write ratio corresponding to each state channel. According to the write ratio corresponding to each state channel, the corresponding state channel in the pre-write link state representation is retained, and the corresponding candidate write channel in the current candidate link state is written into the pre-write link state representation to obtain the event constraint link state representation.

[0123] The event chain input object is represented as: in, This represents the event chain input object corresponding to the semantic change event currently pending processing; This represents the index of the semantic change events currently pending processing; Represents a vector of semantic change event fields; Represents a vector of shared processing link identifier fields; A vector of fields representing the mixed operational status of the shared processing link; This indicates the link state representation before writing.

[0124] The event attribution written to the gating system generated in step S4 is represented as follows: ; in, Indicate event attribution by writing to the gating; to This represents 128 channel-level gating values.

[0125] The link state before writing is represented as follows: ;in, This represents the link state before the current semantic change event is written; to This represents 128 status channels. The event link input object, event attribution write gate, and pre-write link status are represented by corresponding event indices and link indices.

[0126] When generating the current candidate link state, the event link input object is fed into the event link representation generation layer. The event link representation generation layer consists of 128 neurons, each fully connected to a 200-dimensional field of the event link input object, and configured with weights, biases, and SiLU nonlinear units. The event link representation generation layer maps the semantic change event field vector, the shared processing link identifier field vector, the shared processing link hybrid running state field vector, and the link state representation before writing to the same channel space, generating the event link representation: ;in, Indicates the event chain representation; to This represents 128 channels. The event link representation is not directly written to the link state representation before writing, but is used as the basis for generating the current candidate link state.

[0127] The event chain representation is used as the input to the value representation generation layer. This generation layer consists of 128 neurons, each fully connected to one of the 128 channels of the event chain representation. It generates the current candidate chain state through short convolutions and SiLU nonlinear units. ;in, Indicates the current candidate link status; to This indicates 128 candidate write channels.

[0128] aisle to Indicates calling the candidate channel for the change; channel to Indicates candidate channels for queue changes; channel to Indicates candidate channels for failed changes; channels to Indicates candidate channels for cache changes; Channel to Indicates candidate channels for load changes; channels to This indicates a candidate channel for link state memory.

[0129] The current candidate link state is used to express the link state content to be written to the shared processing link state representation within the current time slice. Since the current candidate link state originates from the event link input object containing mixed operating states, the candidate content formed at this stage has not yet independently distinguished between the current semantic change event, other subgraph concurrent tasks, and common load fluctuations.

[0130] When forming candidate write constraint objects, the channel value of each candidate write channel in the current candidate link state is multiplied by the corresponding channel-level gate value in the event-attributed write gate. For any write channel index The corresponding channel value is determined according to the following formula: ;in, Indicates the candidate to be written into the qualified object. Channel values ​​for each channel; Indicates the current candidate link state of the first... Channel values ​​for each candidate write channel; The event attribution is written into the gating. Individual channel-level gating values; This indicates writing to the channel index, and .

[0131] The candidate write limit object is composed of the values ​​of each channel: ;in, This indicates the candidate write constraint object. The channel order represented by the candidate write constraint object, the current candidate link state, the event-attributed write gate, and the link state before writing must be consistent.

[0132] In the event attribution write gating, the gated channels corresponding to the ontology transformation binding relationship retain the writable content of the current candidate link state; the gated channels not limited by the ontology transformation binding relationship but affected by the multiplexing pressure state constrain the corresponding candidate write content. Thus, the channel values ​​in the candidate write constraint object respectively reflect the impact of the current semantic change event on the write of the corresponding link state channel.

[0133] When determining the write ratio, the channel values ​​of each channel in the candidate write limit objects are limited to a preset ratio limit range. For the first... For each channel, the write ratio is determined according to the following formula:

[0134] in, Indicates the first The write ratio corresponding to each status channel; Indicates the candidate to be written into the qualified object. Channel values ​​for each channel; Indicates the lower boundary of the preset ratio limit range; This indicates the upper boundary of the preset ratio limit interval; the preset ratio limit interval is a closed interval. .

[0135] A write ratio vector is formed by the write ratio corresponding to each status channel: ; in, Indicates the write ratio; to These represent the write ratios corresponding to the 128 status channels.

[0136] For channels that have an ontology transformation binding relationship with the current semantic change event, the write ratio retains the write strength of the current candidate link state; for channels that are not limited by the ontology transformation binding relationship and are affected by the multiplexing pressure state, the write ratio limits the degree of writing from the current candidate link state to the link state before writing.

[0137] According to the write ratio corresponding to each state channel, the corresponding state channel in the pre-write link state representation is retained, and the corresponding candidate write channel in the current candidate link state is written into the pre-write link state representation. For the first... Each state channel, and the event constraint link state are determined according to the following formula: ; in, The first event constraint link state representation in the event constraint link state representation One status channel; This indicates the first step in the link state representation before writing. One status channel; Indicates the current candidate link state of the first... One candidate write channel; Indicates the first The write ratio corresponding to each status channel; This indicates the retention ratio of the corresponding state channel in the link state representation before writing.

[0138] The event constraint link state representation is formed by the combined state channels: ; in, This represents the state of the event constraint link; to This represents 128 status channels.

[0139] The meaning of the event-constrained link state representation is consistent with that of the link state representation before writing, including the call change memory channel, queue change memory channel, failure change memory channel, cache change memory channel, load change memory channel, and link state memory channel.

[0140] The event-constrained link state representation is neither an external scoring result of the mixed operation state of the shared processing link nor an overall reception result of the current candidate link state. Instead, it is a link state representation formed within the state update model after the event-attributed write gating controls the write ratio of each channel.

[0141] Step S6: Calculate the channel difference between the event constraint link state representation and the link state representation before writing, and obtain and output the event-attributed running state increment corresponding to the semantic change event.

[0142] Step S6 compares the link state after the event attribution gating constraint is written with the link state before the write in the same channel, and forms the call change, queue change, failure change, cache change, load change, and link state memory change corresponding to the current semantic change event according to the meaning of each state channel. Since the event constraint link state participating in the difference calculation has already undergone the joint constraints of state writing eligibility and reuse pressure state, the calculation result is used to express the shared processing link state change caused by the current semantic change event.

[0143] Specifically, the differences between the event constraint link state representation and the link state representation before writing are calculated to form a link state difference object; according to the preset channel range, call changes, queue changes, failure changes, cache changes, load changes, and link state memory changes are determined from the link state difference object; the channel difference values ​​corresponding to call changes, queue changes, failure changes, cache changes, load changes, and link state memory changes are written into the corresponding incremental channels in channel order to form and output the event-assigned running state increment.

[0144] The event constraint link state is represented as follows: ;in, This represents the index of the semantic change events currently pending processing; This represents the state of the event constraint link formed after the current semantic change event has been written through the event attribution gating control. to This represents 128 status channels.

[0145] The link state representation before writing is denoted as: ;in, This represents the shared processing link state before the current semantic change event was written. to This represents 128 status channels.

[0146] The event-constrained link state representation and the pre-write link state representation use the same number of channels, channel order, and channel meaning. Channels 1 to 24 correspond to call change memory channels, channels 25 to 48 correspond to queue change memory channels, channels 49 to 72 correspond to failure change memory channels, channels 73 to 96 correspond to cache change memory channels, channels 97 to 112 correspond to load change memory channels, and channels 113 to 128 correspond to link state memory channels.

[0147] Calculate the difference between corresponding state channels in the two link state representations. For any state channel index... The difference value of the corresponding channel is determined according to the following formula: ; in, Indicates the first Channel difference values ​​for each state channel; The first in the event constraint link state representation One status channel; Indicates the first in the link state representation before writing One status channel; Indicates the state channel index, and .

[0148] The link state difference object is formed by the channel difference values ​​corresponding to each state channel: ; in, Represents a link state difference object; to This represents the channel difference value of 128 status channels.

[0149] The calculation of the corresponding channel state difference is only performed between state channels with the same channel meaning. Different channels are not merged, and the event constraint link state representation is not externally scored or secondary filtered, thereby maintaining the direct correspondence between the state changes before and after writing and the operating state type of each link.

[0150] According to the preset channel range of the link state difference object, channels 1 to 24 are determined as call change fields, which are used to express the call state difference of the shared processing link before and after the current semantic change event constraint is written; channels 25 to 48 are determined as queue change fields, which are used to express the state differences corresponding to changes in task queue waiting, queue carrying, and queue running.

[0151] Channels 49 to 72 are designated as failure change fields to express the state differences corresponding to failed calls, consecutive failures, and changes in failure rate; channels 73 to 96 are designated as cache change fields to express the state differences corresponding to cache hits, cache misses, and changes in cache load.

[0152] Channels 97 to 112 are designated as load change fields to express the state differences corresponding to current load occupancy, load changes, and common load fluctuations; channels 113 to 128 are designated as link state memory change fields to express the changes in shared processing link state memory before and after the current semantic change event is written.

[0153] Based on the above changes in call, queue, failure, cache, load, and link state memory, an event-attributed runtime state increment is constructed: ; in, This indicates the increment of the runtime status corresponding to the current semantic change event; to This indicates 128 incremental channels.

[0154] When constructing the event-attributed runtime status increment, the channel difference values ​​in the link status difference object are written to the corresponding increment channel in the original channel order, ensuring that the event-attributed runtime status increment and the link status difference object maintain the same channel order and channel meaning. Specifically, increment channels 1 to 24 correspond to call changes, increment channels 25 to 48 correspond to queue changes, increment channels 49 to 72 correspond to failure changes, increment channels 73 to 96 correspond to cache changes, increment channels 97 to 112 correspond to load changes, and increment channels 113 to 128 correspond to link status memory changes.

[0155] The process of forming the event-attributed runtime status increment does not introduce external scoring values, task number allocation values, or call count allocation values. Instead, it directly uses the state channel differences after the event attribution is written into the gating constraint. Therefore, the event-attributed runtime status increment corresponds to the shared processing link status change caused by the currently pending semantic change event and serves as the output result of this dynamic graph data processing.

[0156] In summary, combining Figure 2The system acquires semantic change events, shared processing link identifiers, mixed operating states of shared processing links, and pre-write link state representations generated by asynchronous updates of the dynamic graph by multiple agents, forming event link input objects. It determines the state transition type corresponding to the semantic change event and the target subgraph region it falls into within the bi-element ontology, and determines the ontology transition binding relationship between the state transition type and the shared processing link based on the shared processing link identifier. It also determines the reuse pressure state based on the mixed operating state of the shared processing link. Furthermore, it uses the ontology transition binding relationship and the reuse pressure state to generate an ontology transition write bias, embedding this bias into the gate value generation position of the state update model with channel-level write gating, forming an event-attributed write gating. Subsequently, it generates the current candidate link state, controls the write ratio of each candidate channel to the pre-write link state representation through the event-attributed write gating, obtains the event-constrained link state representation, and forms the event-attributed operating state increment corresponding to the semantic change event based on the channel difference between the event-constrained link state representation and the pre-write link state representation.

[0157] By using a bi-element ontology, the state transition direction and target subgraph scope corresponding to a semantic change event are determined. Ontology transformation binding relationships are used to limit the eligibility of the current semantic change event to write state onto the shared processing link, ensuring that state changes in shared processing links such as extraction rules, cleaning scripts, cache partitions, task queues, and code generation templates have clear event attribution criteria. Simultaneously, the reused stress state reflects the impact of concurrent tasks in other subgraphs, common load fluctuations, queue load, and cache load on the shared processing link, and together with the ontology transformation binding relationship, forms a channel-level write bias, limiting the write ratio of irrelevant state channels before the actual writing of candidate link states. Therefore, the event-constrained link state representation can accurately retain call changes, queue changes, failure changes, cache changes, load changes, and link state memory changes caused by the current semantic change event, reducing the degree to which operational changes corresponding to other tasks and common loads are mixed into the current event link state, and improving the accuracy and consistency of event-attributed operational state increments.

[0158] Furthermore, to illustrate the specific network structure of the shared processing link state writing model and to verify the impact of ontology conversion binding relationships, reuse of stressed states, ontology conversion writing bias, and event attribution writing gating on the state writing results, semantic change events generated in the dynamic graph are used for verification through asynchronous updates by multiple agents. Semantic change events include entity category expansion, addition of relation edges, attribute hierarchy changes, and target subgraph structure changes. The shared processing link includes extraction rules, cleaning scripts, cache partitioning, task queues, and code generation templates.

[0159] The validation data consists of four parts: event chain details, channel status sampling, model variant summary, and subgraph scenario comparison. The number of records, record granularity, and key fields of each part are shown in Table 1.

[0160] Table 1. Data Structure and Field Sources for Examples

[0161] Table 1 shows that the event chain details include 360 ​​event-level records, mainly recording event identifiers, semantic change types, shared processing chain identifiers, mixed operating states, gating values, and state norms; the channel state sampling includes 6480 channel-level records, mainly recording channel numbers, channel groups, channel values ​​before writing, candidate channel values, gating values, and channel values ​​after writing. The model variant summary includes 6 ablation summary records, used to save the state update error, mixed write contamination rate, and recognition F1 value corresponding to each model variant; the subgraph scene comparison includes 36 records of target subgraphs and model correspondences, used to analyze the recognition results and state write contamination in different target subgraph regions.

[0162] To further illustrate the data correspondence between different semantic change events and the shared processing link, some event link details were selected as representative records, as shown in Table 2.

[0163] Table 2 Representative records of event chain details

[0164] Each record in Table 2 corresponds to a semantic change type, such as entity category expansion, target subgraph structure change, addition of relation edges, and attribute level change, and is matched with shared processing links such as cleaning scripts, task queues, cache partitions, and extraction rules. Table 2 also provides the ontology conversion binding strength, reuse pressure state value, event attribution write threshold value, and event attribution running state increment for each event, which are used to reflect the write eligibility, reuse impact, and final state change of different semantic change events in the shared processing links.

[0165] In terms of model structure, the event link input object is a 200-dimensional vector, including a 32-dimensional semantic change event field vector, a 16-dimensional shared processing link identifier field vector, a 24-dimensional shared processing link hybrid running state field vector, and a 128-dimensional pre-write link state representation. The input mapping layer maps the 200-dimensional event link input object to a 128-dimensional event link representation and uses the SiLU activation function for nonlinear processing.

[0166] The dual-element ontology mapping layer receives a 128-dimensional event link representation, and generates a 32-dimensional state transition type representation and a 32-dimensional target subgraph region representation through two parallel mapping branches, which are then concatenated to form a 64-dimensional target subgraph transformation object. The link writing constraint layer receives the 64-dimensional target subgraph transformation object, a 16-dimensional shared processing link identifier field vector, and a 24-dimensional shared processing link mixed running state field vector, which are concatenated to form a 104-dimensional constraint input, and then mapped sequentially to a 128-dimensional intermediate representation and a 64-dimensional link writing constraint object. In the 64-dimensional link writing constraint object, the first 32 dimensions express the ontology transformation binding relationship, and the last 32 dimensions express the reuse pressure state.

[0167] The ontology transformation write bias generation layer receives a 64-dimensional link write constraint object and outputs a 128-dimensional ontology transformation write bias. Each bias channel corresponds one-to-one with the 128 native write gating channels in the state update model. The ontology transformation write bias only embeds the gating value generation position of the native write gating, without changing the erase gating, key representation generation process, or the current candidate link state generation process. The input and output dimensions, processing structure, and activation function of each network structural unit are shown in Table 3.

[0168] Table 3 Model structural units, dimensions, and activation functions

[0169] As shown in Table 3, the input mapping layer uses a fully connected mapping from 200 to 128 dimensions; the bi-element ontology mapping layer uses two parallel fully connected mapping branches; the link writing constraint layer uses mapping structures from 104 to 128 dimensions and from 128 to 64 dimensions respectively; and the ontology transformation writing bias generation layer uses a mapping from 64 to 128 dimensions. The query representation generation layer, key representation generation layer, and value representation generation layer all use fully connected layers, one-dimensional short convolutions with a kernel width of 3, and the SiLU activation function, where the value representation generation layer outputs a 128-dimensional current candidate link state.

[0170] The shared processing link state update process receives 128-dimensional current candidate link state, 128-dimensional event attribution write gating, and 128-dimensional pre-write link state representation. The event attribution write gating limits the proportion of writes from the current candidate link state to the pre-write link state representation at the channel level. The event-constrained link state representation is divided into six channel categories based on channel range: call change, queue change, failure change, cache change, load change, and link state memory.

[0171] To illustrate the specific effects of event attribution writing gating on different state channels, some channel state sampling records were selected, as shown in Table 4.

[0172] Table 4. Representative records of channel-level state sampling

[0173] Table 4 lists the pre-write channel value, candidate channel value, gating value, post-write channel value, and channel difference value for channel groups such as call change, queue change, and failure change. As shown in Table 4, different state channels within the same semantic change event have different gating values ​​and post-write channel values. This indicates that the event-attributed write gating does not involve overall reception or suppression of the current candidate link state, but rather controls the write ratio for each state channel individually.

[0174] To verify the impact of different technical features on event attribution results, six model variants were set up. Model M0 is the complete model, retaining the bi-element ontology mapping, ontology transformation binding relationship, reuse pressure state, ontology transformation write bias, and event attribution write gating; Model M1 removes the ontology transformation write bias; Model M2 removes the reuse pressure state; Model M3 removes the ontology transformation binding relationship; Model M4 directly adopts the native write gating of Gated DeltaNet-2; Model M5 performs post-event amortization of state changes at the output. The verification results of each model variant are shown in Table 5.

[0175] Table 5 Summary of Model Variant Ablation

[0176] As shown in Table 5, the average state update error of the complete model M0 is 0.1072, the average mixed write contamination rate is 0.1514, the average event attribution consistency is 0.8705, and the average identification F1 value is 0.7273. After removing the ontology conversion write bias, multiplexing pressure state, and ontology conversion binding relationship from models M1, M2, and M3, respectively, the average mixed write contamination rates increase to 0.3096, 0.3438, and 0.3669.

[0177] Model M4 directly employs native write gating, achieving an average mixed write pollution rate of 0.4503 and reducing average event attribution consistency to 0.6478. Model M5 uses an output-side post-allocation method, achieving an average mixed write pollution rate of 0.3754. These data indicate that ontology conversion binding relationships, reuse stress states, and ontology conversion write bias all have practical effects on reducing mixed write pollution. Embedding constraints into the state write phase is also superior to post-allocation at the output end.

[0178] Furthermore, to verify the applicability of event attribution writing gating in different target subgraph regions, the average recognition F1 scores of each model variant in the six target subgraph regions were compared, as shown in Table 6.

[0179] Table 6. Average F1 score for different target sub-image regions.

[0180] As shown in Table 6, the average F1 score of the complete model M0 in the six target subgraph regions ranges from 0.7187 to 0.7392, and is higher than other model variants in each target subgraph scenario. This result indicates that the state writing eligibility constraint formed between the ontology transformation binding relationship and the target subgraph region is not only applicable to a single subgraph type, but also maintains relatively stable event attribution recognition performance under different semantic structures and different shared processing links.

[0181] In summary, Tables 1 and 2 illustrate the composition of the verification data and the event-level data relationships; Table 3 describes the specific network structure of the shared processing link state writing model; Table 4 explains the role of event attribution writing gating in the channel-level state writing process; and Tables 5 and 6 respectively verify the ablation effect of each core technical feature and its applicability under different target subgraph regions. The verification results show that ontology conversion binding relationships, reuse pressure states, and ontology conversion writing biases jointly participate in the channel-level constraints of the writing phase, which can reduce the degree to which operational changes unrelated to the current semantic change event enter the link state representation, and improve the accuracy and consistency of event-attributed operational state increments.

[0182] Furthermore, to verify the constraint effect of the event attribution writing mechanism on the shared processing link state update from different dimensions, combined with Figures 3 to 5 A comparative analysis was conducted between the complete model and various ablation variants. Figure 3 The mixed write pollution rate curve under shared link load is used to verify the ability of each model to suppress the running state of non-current semantic change events when the shared processing link load continues to increase. Figure 4 The ablation heatmap of the target subgraph scene is used to verify the recognition stability and hybrid write control capability of different models in multiple target subgraph regions; Figure 5 The graph shows the index loss of the ablation variant relative to the complete model, used to verify the impact of ontology transformation write bias, reuse stress state, ontology transformation binding relationship, and write stage constraint method on model performance.

[0183] Figure 3Plotting shared link load on the horizontal axis and hybrid write pollution rate on the vertical axis, the pollution rate changes are shown for the complete model, models with removed ontology transformation write bias, models with removed multiplexed stressed states, models with removed ontology transformation bindings, models using native write gating, and models using output-side amortization. As shared link load increases, the hybrid write pollution rate of each ablation variant shows a significant upward trend, while the complete model remains at a low level with minimal fluctuations. This result indicates that when the shared processing link simultaneously carries more subgraph tasks and common load changes, relying solely on native write gating or output-side amortization is insufficient to prevent irrelevant runtime changes from entering the link state representation. When ontology transformation bindings and multiplexed stressed states jointly participate in write gating, it can continuously limit the state channels corresponding to non-current semantic change events during the write phase, reducing hybrid write pollution caused by increased link load.

[0184] Figure 4 Using target subgraph regions and model variants as comparative dimensions, the average recognition F1 score and average mixed write contamination rate are presented under different target subgraph scenarios. The complete model maintains a high average recognition F1 score and a low average mixed write contamination rate in all target subgraph regions. However, after removing ontology transformation write bias, reuse stress state, or ontology transformation binding relationships, the recognition F1 score decreases and the mixed write contamination rate increases. These performance differences are more pronounced when using native write gating and output-end amortization. These results indicate that the state write constraints of this application are not only targeted at a specific target subgraph or a specific semantic change type, but can also appropriately limit the state write channels in different target subgraph scenarios based on the binding relationship between state transformation type, target subgraph region, and shared processing link, thereby maintaining the consistency of event attribution recognition results.

[0185] Figure 5 Using the complete model as a baseline, the relative changes of each ablation variant in terms of average state update error, average mixed write contamination rate, average event attribution consistency, average identification F1 score, and average processing latency are presented. After removing the ontology transformation write bias, the model loses its ability to convert write eligibility and reuse effects into channel-level gating constraints; after removing the reuse pressure state, the model struggles to identify the mixed effects caused by other subgraph tasks and common load fluctuations; after removing ontology transformation binding relationships, the model struggles to determine the state write eligibility of the current semantic change event for the shared processing link. When using native write gating or output-side amortization, the mixed write contamination rate and state update error further increase, while event attribution consistency and identification F1 score decrease accordingly. These results indicate that the event attribution effect is not independently generated by a single technical feature, but rather is formed by the combined effects of ontology transformation binding relationships, reuse pressure state, ontology transformation write bias, and channel-level gating during the write phase.

[0186] therefore, Figure 3The main demonstration is that this application can still suppress mixed write pollution even when the shared link load increases. Figure 4 The main purpose is to demonstrate that this application has a stable event attribution identification capability in different target sub-graph regions. Figure 5 The main evidence demonstrates that each core technical feature contributes practically to the state write constraint effect. Three sets of illustrations, from the perspectives of load change, scenario change, and technical feature ablation, jointly verify that this application can more accurately determine the link's operational state change corresponding to the current semantic change event when the shared processing link is simultaneously affected by the current semantic change event, other subgraph tasks, and common load fluctuations.

[0187] Figure 6 This is a structural block diagram of a dynamic map data processing system based on multi-agent cooperation and dual-element ontology provided in one embodiment of this application. The system includes at least the following modules: The event link construction module is used to acquire semantic change events, shared processing link identifiers, shared processing link mixed operation status and link status representation before writing generated by multi-agent asynchronous updates of dynamic graph, and form event link input objects; The ontology transformation and recognition module is used to determine the state transformation type corresponding to the semantic change event in the dual-element ontology based on the input object of the event chain, and to determine the target subgraph region in which the state transformation type falls. The link constraint determination module is used to combine the state transition type, target subgraph region and shared processing link identifier to determine the ontology transformation binding relationship between the state transition type and the shared processing link, and to determine the multiplexing pressure state based on the mixed operation state of the shared processing link. The write gate generation module is used to generate the ontology conversion write bias by utilizing ontology conversion binding relationship and reuse pressure state, and embed the ontology conversion write bias into the gate value generation position of the state update model with channel-level write gate, and the generation event belongs to the write gate. The link state update module is used to generate the current candidate link state based on the event link input object, and control the proportion of the current candidate link state to be written to the channel level of the link state before writing through the event attribution write gating, so as to obtain the event-constrained link state representation. The state increment output module is used to calculate the channel difference between the event constraint link state representation and the link state representation before writing, and to obtain and output the event-attributed running state increment corresponding to the semantic change event.

[0188] For relevant details, please refer to the above method implementation examples.

[0189] Figure 7 This is a block diagram of an electronic device provided in one embodiment of this application. The device includes at least a processor 701 and a memory 702.

[0190] Processor 701 may include one or more processing cores, such as a 4-core processor or an 8-core processor. Processor 701 may be implemented in at least one hardware form selected from DSP (Digital Signal Processor), FPGA (Field-Programmable Gate Array), or PLA (Programmable Logic Array). Processor 701 may also include a main processor and a coprocessor, wherein the main processor, also known as a CPU (Central Processing Unit), processes data when the device is in operation; the coprocessor performs low-power or auxiliary computing tasks. In some embodiments, processor 701 may also integrate a GPU (Graphics Processing Unit) for performing parallel computing or graphics processing tasks; processor 701 may also include an AI (Artificial Intelligence) processor for performing machine learning computation operations related to bi-element ontology mapping, state update model inference, and event attribution writing gating.

[0191] The memory 702 may include one or more computer-readable storage media, which may be non-transitory storage media. The memory 702 may also include high-speed random access memory and non-volatile memory, such as one or more disk storage devices or flash memory devices. In some embodiments, the non-transitory computer-readable storage media in the memory 702 is used to store at least one instruction, which, when executed by the processor 701, implements the dynamic map data processing method based on multi-agent cooperation and dual-element ontology provided in the embodiments of this application.

[0192] Optionally, this application also provides a computer-readable storage medium storing a program that is loaded and executed by a processor to implement the dynamic map data processing method based on multi-agent cooperation and dual-element ontology described in the above method embodiments.

[0193] Optionally, this application also provides a computer product including a computer-readable storage medium storing a program, which is loaded and executed by a processor to implement the dynamic map data processing method based on multi-agent cooperation and dual-element ontology described in the above method embodiments.

[0194] The above embodiments merely illustrate several implementation methods of this application, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the invention patent. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this patent application should be determined by the appended claims.

Claims

1. A dynamic map data processing method based on multi-agent collaboration and dual-element ontology, characterized in that, The method includes: Acquire semantic change events, shared processing link identifiers, mixed running states of shared processing links, and pre-write link states generated by asynchronous updates of the dynamic graph by multiple agents, and form event link input objects; Based on the event chain input object, determine the state transition type corresponding to the semantic change event in the dual-element ontology, and determine the target subgraph region into which the state transition type falls; By combining the state transition type, the target subgraph region, and the shared processing link identifier, the ontology transition binding relationship between the state transition type and the shared processing link is determined, and the reuse pressure state is determined based on the mixed operation state of the shared processing link. The ontology conversion binding relationship and the multiplexing pressure state are used to generate an ontology conversion write bias, and the ontology conversion write bias is embedded into the gate value generation position of the state update model with channel-level write gating to generate the event-attributed write gating. The current candidate link state is generated based on the event link input object, and the proportion of channel-level writing from the current candidate link state to the link state before writing is controlled by the event attribution writing gating to obtain the event-constrained link state representation. Calculate the channel difference between the event constraint link state representation and the link state representation before writing, and obtain and output the event-attributed running state increment corresponding to the semantic change event.

2. The dynamic map data processing method based on multi-agent collaboration and dual-element ontology according to claim 1, characterized in that, The process of acquiring semantic change events generated by asynchronous updates of the dynamic graph by multiple agents, shared processing link identifiers, mixed operating states of shared processing links, and pre-write link state representations to form an event link input object includes: The original semantic change events are sorted according to timestamps, the currently pending semantic change events are read, and the changes corresponding to entity category expansion, relation edge addition, attribute level change and target subgraph structure change are parsed to form a semantic change event field vector. The change type and subgraph identifier of the semantic change event are matched with the preset link matching table to determine the shared processing link identifier. Based on the extraction rules, cleaning script, cache partition, task queue and code generation template corresponding fields in the matching table, a shared processing link identifier field vector is formed. Using the shared processing link identifier as a filtering condition, obtain the running status sampling records within a preset status window based on the generation time of the semantic change event, and form a shared processing link hybrid running status field vector. Obtain the link state representation corresponding to the shared processing link identifier and whose formation time is earlier than the generation time of the semantic change event. Determine the link state representation whose formation time is closest to the generation time as the pre-write link state representation. If no link state representation that meets the conditions is obtained, use the preset initial state representation as the pre-write link state representation. The semantic change event field vector, the shared processing link identifier field vector, the shared processing link hybrid operation status field vector, and the pre-write link status representation are arranged in a fixed field order to form the event link input object.

3. The dynamic map data processing method based on multi-agent collaboration and dual-element ontology according to claim 1, characterized in that, The step of determining the state transition type corresponding to the semantic change event in the dual-element ontology based on the event chain input object, and determining the target subgraph region into which the state transition type falls, includes: The event chain input object is mapped to an event chain representation, and based on the semantic element set in the dual-element ontology, the representation channel corresponding to the semantic change event field in the event chain representation is mapped to form a semantic change boundary; The semantic change boundary is matched with the semantic element identifier in the semantic element set to generate a set of state transition candidate types; The trigger field, starting state, and target subgraph constraint of each of the aforementioned state transition candidate types are matched with the state transition rule table in the bi-element ontology, and the state transition type is determined according to the rule priority. The target subgraph region is determined by matching the target subgraph constraint carried by the state transition type with the subgraph index table in the semantic element set.

4. The dynamic map data processing method based on multi-agent collaboration and dual-element ontology according to claim 1, characterized in that, The process involves combining the state transition type, the target subgraph region, and the shared processing link identifier to determine the ontology transition binding relationship between the state transition type and the shared processing link, and determining the reuse pressure state based on the mixed operation state of the shared processing link, including: The state transition type and the shared processing link identifier are matched with a preset link matching table to determine the link pointing record; The target subgraph region and the shared processing link identifier are matched with the link function configuration table to determine the link function record; The link action record, the state transition type, and the target subgraph region are matched with the state writing qualification rule table to obtain the ontology transformation binding relationship that characterizes the state writing qualification between the state transition type and the shared processing link; Based on the call frequency, queue waiting time, failure rate, cache hit rate, load changes, and time slice changes in the hybrid operation state of the shared processing link, the reuse occupancy determination object is determined, and the reuse occupancy determination object is matched with the reuse pressure determination rule table to obtain the reuse pressure state.

5. The dynamic map data processing method based on multi-agent collaboration and dual-element ontology according to claim 1, characterized in that, The process of generating an ontology conversion write bias using the ontology conversion binding relationship and the multiplexing pressure state, and embedding the ontology conversion write bias into the gate value generation position of the state update model with channel-level write gating, and generating an event belonging to the write gating, includes: Based on the state write qualification flag in the ontology conversion binding relationship, a write qualification limit object is generated, valid state write qualification flags are written to the corresponding channels, and invalid state write qualification flags are set to zero in the corresponding channels. By combining the write qualification restriction object and the multiplexing pressure state, a write impact restriction object is generated, retaining the write channel corresponding to the state transition type with state write qualification, and restricting the write channel that is not limited by the ontology transition binding relationship but is affected by the multiplexing pressure state; The write impact limiting object is mapped to an ontology conversion write bias that corresponds one-to-one with each write channel of the state update model; The original write signal generated at the gate value generation position by the channel-level write gate is obtained, and the body conversion write bias is embedded into the original write signal according to the channel correspondence, the gate value of each write channel is updated, and the event-attributed write gate is generated. The state update model is Gated DeltaNet-2, and the ontology conversion write bias only applies to the channel-level write gate.

6. The dynamic map data processing method based on multi-agent collaboration and dual-element ontology according to claim 1, characterized in that, The step of generating a current candidate link state based on the event link input object, and controlling the channel-level write ratio of the current candidate link state to the link state before writing through the event attribution write gating, to obtain the event-constrained link state representation, includes: The event link input object is mapped to an event link representation, and the event link representation input value is used to represent the generation layer to generate the current candidate link state, which includes multiple candidate write channels; Multiply the channel value of each candidate write channel in the current candidate link state with the corresponding channel-level gate value in the event-attributed write gate to form a candidate write constraint object; The channel value of each channel in the candidate write-limited object is limited to a preset ratio limit range to obtain the write ratio corresponding to each state channel; According to the write ratio corresponding to each state channel, the corresponding state channel in the pre-write link state representation is retained, and the corresponding candidate write channel in the current candidate link state is written into the pre-write link state representation to obtain the event-constrained link state representation.

7. The dynamic map data processing method based on multi-agent collaboration and dual-element ontology according to claim 1, characterized in that, The calculation of the channel difference between the event constraint link state representation and the link state representation before writing, to obtain and output the event attribution runtime state increment corresponding to the semantic change event, includes: The difference calculation is performed on the state channels with the same channel meaning in the event-constrained link state representation and the pre-write link state representation to form a link state difference object; According to the preset channel range, call changes, queue changes, failure changes, cache changes, load changes, and link state memory changes are determined from the link state difference objects; The channel difference values ​​corresponding to the call change, queue change, failure change, cache change, load change, and link state memory change are written into the corresponding incremental channels in channel order to form and output the event-assigned running state increment.

8. A dynamic map data processing system based on multi-agent collaboration and dual-element ontology, characterized in that, include: The event link construction module is used to acquire semantic change events, shared processing link identifiers, shared processing link mixed operation status and link status representation before writing generated by multi-agent asynchronous updates of dynamic graph, and form event link input objects; The ontology transformation and recognition module is used to determine the state transformation type corresponding to the semantic change event in the dual-element ontology based on the event link input object, and to determine the target subgraph region into which the state transformation type falls. The link constraint determination module is used to combine the state transition type, the target subgraph region, and the shared processing link identifier to determine the ontology transformation binding relationship between the state transition type and the shared processing link, and to determine the reuse pressure state based on the mixed operation state of the shared processing link. The write gate generation module is used to generate an ontology conversion write bias using the ontology conversion binding relationship and the multiplexing pressure state, and to embed the ontology conversion write bias into the gate value generation position of the state update model with channel-level write gate, and to generate an event belonging to the write gate. The link state update module is used to generate the current candidate link state based on the event link input object, and control the channel-level write ratio of the current candidate link state to the link state before writing through the event attribution write gate to obtain the event-constrained link state representation; The state increment output module is used to calculate the channel difference between the event constraint link state representation and the link state representation before writing, and to obtain and output the event-attributed running state increment corresponding to the semantic change event.

9. An electronic device, characterized in that, The device includes a processor and a memory; the memory stores a program, which is loaded and executed by the processor to implement a dynamic map data processing method based on multi-agent collaboration and dual-element ontology as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The storage medium stores a program, which, when executed by a processor, is used to implement a dynamic graph data processing method based on multi-agent collaboration and dual-element ontology as described in any one of claims 1 to 7.

Images