A method for agent decision-making path optimization that integrates explicit topology and implicit semantics

Abstract

This invention relates to the field of artificial intelligence technology, and more particularly to an agent decision-making path optimization method integrating explicit topology and implicit semantics. The method includes the following steps: acquiring multimodal data; performing document parsing based on the multimodal data to obtain document parsing data; performing knowledge injection based on the document parsing data to obtain knowledge injection data; performing implicit semantic detection based on the knowledge injection data to obtain implicit semantic data; constructing a user-demand agent blueprint based on the implicit semantic data; constructing an agent workflow based on the user-demand agent blueprint; scheduling task execution based on the agent workflow to obtain task execution data; constructing explicit node topology based on the task execution data to obtain explicit node topology data; and performing communication anomaly analysis based on the explicit node topology data to obtain node communication anomaly data. This invention achieves agent task scheduling and path optimization based on artificial intelligence technology, improving the system's resource utilization.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and in particular to an agent decision-making path optimization method that integrates explicit topology and implicit semantics. Background Technology

[0002] Traditional agent-based decision-making path optimization often relies solely on static network structures in topology modeling, failing to capture real-time changes in communication link states and dynamically reflect communication anomalies or real-time adjustments to the topology. This results in slow response times for path optimization in unforeseen scenarios. Regarding implicit semantic understanding, it commonly relies on shallow semantic matching or keyword extraction, failing to effectively identify deep semantic dependencies in user needs and hindering accurate parsing of complex intentions. This, in turn, affects the accuracy of agent task orchestration and resource binding. Furthermore, path optimization strategies generally lack reinforcement learning-driven multi-agent collaboration mechanisms, leading to an inability to balance global resource load and local task priorities during task scheduling. This results in decision conflicts and untimely detection and optimization of resource bottlenecks, reducing the overall system's adaptability and robustness in dynamic environments. Finally, anomaly detection and path reordering mostly employ rule-based or static priority schemes, failing to automatically detect and intelligently reorder task conflicts, making it difficult to adapt to the high-concurrency, highly dynamic agent collaboration requirements of large-scale distributed environments. Summary of the Invention

[0003] Therefore, the present invention needs to provide an agent decision path optimization method that integrates explicit topology and implicit semantics to solve at least one of the above-mentioned technical problems.

[0004] To achieve the above objectives, an agent decision-making path optimization method integrating explicit topology and implicit semantics is proposed, comprising the following steps:

[0005] Step S1: Obtain multimodal data; perform document parsing based on the multimodal data to obtain document parsing data; perform knowledge injection based on the document parsing data to obtain knowledge injection data;

[0006] Step S2: Perform implicit semantic detection based on the knowledge injection data to obtain implicit semantic data; construct a user requirement intelligent agent blueprint based on the implicit semantic data; construct an intelligent agent workflow based on the user requirement intelligent agent blueprint; perform task execution scheduling based on the intelligent agent workflow to obtain task execution data;

[0007] Step S3: Construct explicit node topology based on task execution data to obtain explicit node topology data; perform communication anomaly analysis based on explicit node topology data to obtain node communication anomaly data; identify abnormal communication links based on node communication anomaly data to obtain abnormal communication link data; perform node resource scheduling based on abnormal communication link data to obtain node resource scheduling data.

[0008] Step S4: Construct a reinforcement learning decision engine based on node resource scheduling data; optimize the decision path of multiple agents based on the reinforcement learning decision engine to obtain decision path optimization data.

[0009] This invention achieves structured expression and semantic enrichment of information by acquiring multimodal data and performing in-depth document parsing and knowledge injection. This effectively enhances the ability to understand complex data, enabling subsequent implicit semantic detection to capture deep-seated semantic dependencies and logical relationships in user needs. This allows for the accurate construction of a user-demand-based intelligent agent blueprint and the rational planning of the agent's workflow, ensuring the scientific and efficient execution scheduling of tasks. The explicit node topology built based on task execution data dynamically reflects the real-time status of the network structure and communication links, promptly identifying and analyzing communication anomalies and abnormal links, enhancing sensitivity and response speed to network anomalies. Node resource scheduling dynamically adjusts to address the impact of abnormal links and resource bottlenecks, optimizing resource allocation, avoiding node overload or resource idleness, and effectively improving the system's load balancing capability. The reinforcement learning decision engine built using node resource scheduling data introduces a multi-agent collaborative mechanism, enabling dynamic trade-offs under global and local resource constraints. This achieves a unified consideration of long-term macro goals and short-term task priorities, significantly reducing scheduling conflicts and resource bottlenecks, and enhancing the system's adaptability and robustness in complex dynamic environments. During the decision path optimization process, the real-time reasoning and adjustment of the reinforcement learning model makes the path planning more flexible and accurate, automatically detects task conflicts and prioritizes and rearranges paths, and realizes intelligent management of scheduling in high-concurrency, multi-task, and multi-agent environments. Attached Figure Description

[0010] Other features, objects, and advantages of the invention will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings:

[0011] Figure 1 This is a flowchart illustrating the steps of an intelligent agent decision path optimization method that integrates explicit topology and implicit semantics according to the present invention.

[0012] Figure 2 This is a detailed flowchart of step S1 in the present invention;

[0013] Figure 3 This is a detailed flowchart of step S16 in the present invention;

[0014] The realization of the objective, functional features and advantages of the present invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0015] The technical method of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this invention. Based on the embodiments of this invention, all other embodiments obtained by those skilled in the art without inventive effort are within the scope of protection of this invention.

[0016] Furthermore, the accompanying drawings are merely illustrative of the invention and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and therefore repeated descriptions of them will be omitted. Some block diagrams shown in the drawings are functional entities and do not necessarily correspond to physically or logically independent entities. These functional entities can be implemented in software, in one or more hardware modules or integrated circuits, or in different network and / or processor methods and / or microcontroller methods.

[0017] It should be understood that although the terms "first," "second," etc., may be used herein to describe various units, these units should not be limited by these terms. These terms are used merely to distinguish one unit from another. For example, without departing from the scope of the exemplary embodiments, a first unit may be referred to as a second unit, and similarly, a second unit may be referred to as a first unit. The term "and / or" as used herein includes any and all combinations of one or more of the associated listed items.

[0018] To achieve the above objectives, please refer to Figures 1 to 3 This invention provides an agent decision-making path optimization method that integrates explicit topology and implicit semantics. The method includes the following steps:

[0019] Step S1: Obtain multimodal data; perform document parsing based on the multimodal data to obtain document parsing data; perform knowledge injection based on the document parsing data to obtain knowledge injection data;

[0020] In this embodiment, an image acquisition module (such as an Intel RealSense D435 camera) and a text data acquisition system are used to synchronously acquire image data and corresponding text task description data from an industrial process monitoring scenario. The image data resolution is set to 1920×1080, and the sampling frequency is 10 frames / second; the text data comes from the process control log system and is uniformly formatted using UTF-8 encoding. The acquired multimodal data is input into a data preprocessing module. The image portion is processed using an image denoising and color normalization algorithm based on OpenCV 4.8, and the text portion is processed using an NLTK word segmenter to perform word segmentation and stop word removal, with the Porter algorithm used for stemming. After preprocessing, a semantic segmentation module is used to segment the text region, setting the average block length to 120 characters and dividing each block into logical paragraphs. Subsequently, Tesseract OCR is used to perform text region recognition on the image data to obtain the bounding box coordinates of the text region. The YOLOv5 model is used to detect objects in the image and extract the location information (x, y, w, h) and category label of each object. Then, based on the spatial relationship between the objects and text within the image, a preliminary image-text association is established. In the vectorization stage, the text portion uses BERT (bert-base-uncased) encoding to convert each semantic block into a 768-dimensional vector; the image portion uses a ResNet-50 feature extraction network to obtain 2048-dimensional feature vectors for the target regions. The image-text features are input into a multimodal alignment module, where a Canonical Correlation Analysis (CCA)-based method is used to model the relevance of image-text vector pairs. A cosine similarity threshold of 0.85 is used for positive example filtering to generate multimodal alignment data. Based on the alignment results, the combined image-text blocks are input into a rule-based semantic parsing engine to perform entity recognition, attribute extraction, and action detection operations, ultimately outputting document parsing data in JSON format. Knowledge injection is performed based on the document parsing data to construct a unified representation structure. Semantic units consist of triples (entity, attribute, action) and are stored in a structured knowledge table. Expert-defined rule bases are used to semantically enhance the triples; for example, when the "job type" is "high-temperature welding" and the "time" field is empty, a safety time stamp field is automatically inserted. The completed knowledge injection result is structured JSON data with 22 fields, including entity category, semantic role label, time attribute, and object location index, identified as knowledge-injected data.

[0021] Step S2: Perform implicit semantic detection based on the knowledge injection data to obtain implicit semantic data; construct a user requirement intelligent agent blueprint based on the implicit semantic data; construct an intelligent agent workflow based on the user requirement intelligent agent blueprint; perform task execution scheduling based on the intelligent agent workflow to obtain task execution data;

[0022] In this embodiment, a contextual feature representation is constructed based on knowledge injection data. This process uses a sliding window mechanism to extract the co-occurrence frequency and order between adjacent triples, setting the window length to 5 semantic units. During feature encoding, a co-occurrence frequency matrix (statistically calculating the joint probability of triple occurrences with a threshold of 0.05) and a sequence dependency graph (calculating order weights using the PageRank algorithm) are calculated, and a contextual graph structure is constructed, represented as graph G=(V,E), where V is the triple node and E is the weighted edge. During semantic association analysis, GAT (Graph Attention) is used to encode the contextual graph. Each triple representation serves as an input node feature, and the attention mechanism weights each edge and calculates the contextual semantic influence factor. Edges with an association strength greater than 0.7 are identified as core semantic paths, generating semantic association data. LSTM encoding is applied to this semantic path to extract deep semantic expressions, with an output dimension of 256, referred to as deep semantic data. In the implicit semantic detection stage, a logistic regression-based pattern matching mechanism is used to discriminate deep semantic data, identifying regions with "reasoning logic chains" features, such as patterns like "if...then..." and "because...leads to...". This rule base includes 21 pattern categories, using Boolean vectors for matching with a matching threshold of 0.9. The extracted pattern sequences form implicit semantic data, marking deep implicit relationships. Based on the implicit semantic data, a blueprint for the user-defined intelligent agent is constructed using template matching. Nine preset blueprint templates (such as data acquisition, resource scheduling, and analysis and evaluation) are used, and mapping matching is performed based on semantic label fields and template conditions. For example, if the semantics include "resource bottleneck + reallocation + path optimization," it matches as a resource scheduling blueprint. The generated blueprint records task input, output, and resource dependencies in a structured form. Based on the module dependencies and task call order defined in the blueprint, a DAG (Directed Acyclic Graph) intelligent agent workflow graph is constructed, where nodes represent specific functional modules (such as information reading and resource allocation), and edges represent data transmission dependencies. Topological sorting is used to organize the task execution order, and the result is used as input for task scheduling. Task scheduling is performed according to the agent's workflow. The scheduling engine traverses the workflow graph, assigning a specific execution position to each task node. The scheduling rules optimize node selection based on metrics such as processing capacity (tasks / sec), current load (%), and response latency (ms). Each task execution records its status, time consumption, and input / output, with the output being task execution data in JSON format.

[0023] Step S3: Construct explicit node topology based on task execution data to obtain explicit node topology data; perform communication anomaly analysis based on explicit node topology data to obtain node communication anomaly data; identify abnormal communication links based on node communication anomaly data to obtain abnormal communication link data; perform node resource scheduling based on abnormal communication link data to obtain node resource scheduling data.

[0024] In this embodiment, an explicit topology is constructed based on the execution node identifiers and communication behaviors recorded in the task execution data. A directed graph is constructed using the NetX library, where nodes are device identifiers (e.g., ID001~ID128) and edges are actual communication records during task execution. Each edge is labeled with the amount of transmitted data (unit: KB), communication timestamp, and communication direction. Edges with more than 3 transmission failure records are designated as edges to be detected. Communication logs are extracted from all edges in the topology, and the packet loss rate (represented by the number of lost frames / total frames, with a threshold of 10%) and out-of-order rate (number of out-of-order packets / total packets, with a threshold of 15%) are calculated. Timestamp sequences are extracted, recording the time periods during which packet loss or out-of-order packets occur, and overlapping time periods are marked as communication anomaly windows. Communication behaviors within the anomaly windows are encapsulated as communication anomaly data. Duplicate request analysis is performed on the communication anomaly data. Data channels that send duplicate requests to the same target node within 5 consecutive times are identified to determine whether they are abnormal access channels; if the number of data packets in an abnormal access channel suddenly increases by more than twice the standard deviation within a unit of time, it is included in the access surge list. The system matches records of sudden access surges. If a match is found in the attack signature database (e.g., a continuous request frequency exceeding 50 times / second), it is recorded as denial-of-service attack data. Further analysis is performed to determine if IP spoofing, port scanning, or other similar behaviors exist, generating intrusion behavior data. Based on the intrusion behavior data, the current communication protocol type (e.g., MQTT, HTTP, gRPC) and protocol version information are identified. A comparison with historical version standard libraries is made; if version incompatibility or encryption algorithm anomalies exist, they are recorded as protocol version anomaly data. All anomaly edges are scored and ranked (with a comprehensive weight of 0.4 for communication error frequency + 0.3 for protocol anomaly + 0.3 for intrusion probability). Those scoring above a set threshold (0.7) are identified as anomaly communication links, generating anomaly communication link data. Based on this link data, the current resource usage of connected nodes is statistically analyzed. CPU utilization (obtained through sampling node system information), memory usage (in MB), and bandwidth utilization (in Mbps) are calculated. Nodes with any one of these metrics exceeding a set threshold (e.g., CPU > 90%, memory > 85%) are identified as bottleneck nodes. Further evaluation of task migration is conducted on bottleneck nodes, calculating the communication overhead required to transfer existing tasks to neighboring nodes, including data volume (MB) and transfer time (s), requiring the overhead to be no more than 80% of the original node's task maintenance time. After determining the migration path, the node task scheduling scheme is reconstructed based on the principle of prioritizing the shortest transfer path length and the lowest node load, and finally, node resource scheduling data is output.

[0025] Step S4: Construct a reinforcement learning decision engine based on node resource scheduling data; optimize the decision path of multiple agents based on the reinforcement learning decision engine to obtain decision path optimization data.

[0026] In this embodiment, task distribution and node status indicators (including CPU utilization, average latency, packet loss rate, memory usage, etc.) are extracted from node resource scheduling data. These state variables are standardized into a unified vector to form scheduling node status data with a dimension of 128. This status data is input into a reinforcement learning system for hierarchical decision modeling. At the macro level, a world model is constructed using model-based reinforcement learning (MBRL). This model uses historical resource scheduling trajectories (recorded over a 90-day period) to train the prediction module. The input is a sequence of task node state vectors, and the output is the business path change trend for the next 30 days. An LSTM dynamic path prediction module is constructed, with prediction accuracy controlled within 10% by mean squared error. Quarterly-level strategy data, including priority task paths and resource redundancy adjustment frequency, is generated based on the prediction output. At the tactical level, a proximal policy optimization (PPO) algorithm is used to optimize task configuration in the short to medium term. The input is a week's worth of task scheduling logs (at minute-level granularity), and the output is a workflow task node adjustment plan. The policy update magnitude is limited by `clipratio=0.2`, and the maximum gradient is set to 0.01 to avoid policy oscillation. At the execution layer, a Deep Q-Network (DQN) is used to fine-tune and optimize the API execution order and degradation scheme (such as switching to a backup node) for each task. An ε-greedy policy is used to control exploration (ε is initially set to 0.5, decreasing by 0.01 every 100 steps), with actions including API reordering, task delay, and discarding low-priority tasks. Finally, by integrating macro-level, tactical, and execution-level policy data, a reinforcement learning decision engine is constructed to generate a policy graph for inference. This graph records all policy paths, conditions, and feedback parameters. Based on this decision engine, multi-agent path optimization operations are performed, sequentially extracting task execution priorities, node execution paths, and optimal resource allocation. The final output is structured JSON-formatted decision path optimization data, with fields including path node sequences, execution time windows, and resource configurations.

[0027] Preferably, step S1 includes the following steps:

[0028] Step S11: Acquire multimodal data and perform data preprocessing to obtain multimodal data to be processed;

[0029] In this embodiment, an integrated multimodal acquisition system is used to collect source data. Text data comes from structured and unstructured industrial equipment operation log files, in formats including CSV, TXT, and XML, all encoded in UTF-8. Image data comes from high-definition cameras installed at key nodes of the production line. The camera model is Sony IMX577, with a resolution of 3840×2160 and a sampling frame rate of 30fps. Text data preprocessing includes: 1) filtering abnormal symbols (e.g., removing all control characters with ASCII codes less than 32), 2) uniformly processing redundant spaces to one space, and 3) uniformly retaining two decimal places for numbers. Image data preprocessing includes: 1) using bilateral filtering for noise reduction, with a filter kernel size of 7×7, color standard deviation σColor=75, and spatial standard deviation σSpace=75; 2) performing histogram equalization to uniformly map the image grayscale range. After all preprocessing operations are completed, the image and text data are combined in the form of structured key-value pairs to form the multimodal data to be processed, with a unified naming format of {task_id,image_array,text_content}.

[0030] Step S12: Identify text regions based on the multimodal data to be processed to obtain text region data; perform semantic segmentation based on the text region data to obtain semantic segmentation data; perform document slicing based on the semantic segmentation data to obtain document slice data;

[0031] In this embodiment, text region localization is performed on the text content in the multimodal data to be processed. A sliding window method is used to divide the text content into regions. The sliding window size is 128 characters, and the step size is 64 characters. Word frequency statistics and key trigger word matching are performed within the window. The trigger words include 72 keywords such as "step," "parameter," "node," and "abnormality." Regions containing core content are extracted as text region data. Semantic block processing is performed on the extracted text region data. A rule-driven syntactic block method is used to divide each sentence into clauses according to punctuation marks ";," "," ".", and conjunctions such as "and," "or," "furthermore," and "subsequently." Each semantic block must be at least 5 words and at least 20 characters long, resulting in semantic block data. Based on the semantic block data, each semantic block is divided into separate document fragments. Each document fragment must retain its original semantic ID, page number, and line number for subsequent semantic mapping. The document slice format is a JSON structure, with fields including "slice_id", "text_span", "origin_doc_id", and "position_index".

[0032] Step S13: Perform image segmentation based on the multimodal data to be processed to obtain image segmentation region data; perform target detection based on the image segmentation region data to obtain image target data; perform target attribute recognition based on the image target data to obtain target attribute data;

[0033] In this embodiment, image segmentation is performed on the images in the multimodal data to be processed. A color-based K-means segmentation algorithm is used to distinguish between foreground and background, with the number of cluster centers set to k=3, and the RGB distance between image pixels used as the clustering basis. During segmentation, the segmentation mask is output as a binary image, the foreground region is labeled, and its area is calculated. Regions with an area less than 5% of the total image area are ignored, and the final output is the image segmentation region data. Based on image segmentation, a feature extraction method based on histogram of orientations (HOG) is used to detect targets in each foreground region. A sliding window (64×64) is used to scan pixel by pixel within the foreground region, while simultaneously calculating the HOG features of each window and matching them with template target features (including categories such as industrial control equipment, tools, and workers) using Euclidean distance, with a matching threshold set to 0.85. Regions that meet the matching criteria are labeled as image target data, including bounding box coordinates (x_min, y_min, x_max, y_max) and category labels. For the identified image target regions, attribute recognition is performed. A template-based geometric attribute extraction method is invoked to perform rectangle fitting on the target contour, extracting geometric attributes such as height, width, aspect ratio, and centroid coordinates. Simultaneously, the grayscale distribution characteristics are statistically analyzed using the image's grayscale histogram, and a grayscale threshold of 85 is set to identify metallic-textured targets. All these parameters are uniformly compiled into target attribute data, stored in XML format, with each object containing 15 attribute fields.

[0034] Step S14: Perform vectorization encoding on the document slice data to obtain semantic vector data; perform feature encoding on the target attribute data to obtain target attribute encoded data;

[0035] In this embodiment, the document slice data is vectorized and encoded. This processing is implemented using the TF-IDF vectorization method, where a bag-of-words model is established with a bag size of 5000. All document slices are input using UTF-8 encoding format. Before encoding, the text content is segmented using a standard word segmentation tool, and stop words are filtered using a predefined stop word list. For each term, its frequency in the current slice is counted, and combined with its frequency in all slices, a word vector of length 5000 is generated. Each dimension corresponds to the TF-IDF weight of a specific term. The generated semantic vector data is stored in sparse matrix form and structured using the COO format of the SciPy library to improve subsequent processing efficiency. Regarding image feature processing, a unified feature encoding operation is performed on the image target data obtained in step S13. First, the bounding box of the image target region is extracted to obtain the height and width values, accurate to the pixel level. The mean gray value is calculated to be between 0 and 255 using pixel grayscale statistics. Then, one-hot encoding is performed based on the identified target category labels. The number of categories is set to 7, corresponding to "equipment," "tools," "personnel," "signs," "instruments," "panels," and "control units," respectively. The one-hot encoding dimension is 7 dimensions. After acquiring the numerical features and category codes of the image, all features are concatenated to form a unified 25-dimensional target attribute encoding data, stored in NumPy array format. Each array data is mapped one-to-one with the corresponding image target. The data organization is a two-dimensional array, where each row represents the complete feature expression of an image target object. Semantic vector data and target attribute encoding data serve as the basis for multimodal alignment and fusion, and an index field must be retained in the structure for subsequent cross-processing.

[0036] Step S15: Perform multimodal alignment processing based on semantic vector data and target attribute encoding data to obtain multimodal aligned data; perform semantic parsing based on multimodal aligned data to obtain document parsing data;

[0037] In this embodiment, semantic vector data and target attribute encoded data are input into the multimodal alignment processing module. A relevance detection method based on Mutual Information Maximization (MIM) is used to calculate the mutual information score for each pair of image-text vectors. A mutual information threshold of 0.8 is set; pairs exceeding this threshold are considered highly relevant image-text pairs and are then labeled. Semantic parsing is performed on the bound image-text pairs. First, the verb and noun part-of-speech tagging results are extracted from the semantic vectors. Then, a regular expression-based entity-relation-object structure parser is called to extract the semantic structure in triple form, for example: {entity: "sensor A", relation: "occurrence", object: "error"}. Simultaneously, the entity and object categories are further corrected based on the image target label information; for example, the image recognition result for "cable" may overwrite the text for "line". Finally, each image-text pair outputs 1-3 triples, which are integrated to form document parsing data, with fields including: entity_type, relation_type, object_type, text_span, and image_id.

[0038] Step S16: Perform knowledge injection based on the document parsing data to obtain knowledge injection data.

[0039] In this embodiment, a unified knowledge representation structure is constructed based on document parsing data. Semantic units extracted from text and images are organized into structured quintuples, including entity identifiers, attribute identifiers, relation identifiers, confidence scores, and source location information. Entity identifiers use a unified numbering method to represent key objects identified in the text or image. Attribute identifiers express quantitative or qualitative descriptions related to the entity. Relationship identifiers describe the logical relationships between the entity and other entities or attributes. The confidence score is calculated in the preceding semantic parsing stage. The source location field records the text line number and image coordinate index from which the quintuple originates. In the constructed knowledge representation vector, the entity spatial number range is controlled between 0000 and 9999, and the relation number range is limited to 000 to 199. All numbers are generated by replacement using a pre-established mapping dictionary. Subsequently, the constructed knowledge representation vector is compared sequentially with a locally deployed expert knowledge base. The expert knowledge base contains over 20,000 structured rule data entries, and a hierarchical retrieval method is used for matching. The matching process follows a step-by-step comparison order: entity, then attribute, and finally relation. A successful match is considered achieved when the system finds any rule data that matches the current knowledge representation vector in terms of entity category, attribute range, and relation context, triggering semantic enhancement. Semantic enhancement appends enhancement information defined in the rules to the current knowledge unit. For example, after identifying the description of an increase in motor equipment temperature, the semantic tag "risk increase" is appended, along with system-suggested entries such as "execute cooling command." All enhanced structured data is re-encoded into a standard RDF triple set. The output format includes subject, predicate, object, confidence score, and source index identifier. All data is recorded and stored in TTL format for subsequent implicit semantic detection and agent inference processes.

[0040] Preferably, step S16 includes the following steps:

[0041] Step S161: Extract semantic unit features from the document parsing data to obtain semantic unit data;

[0042] In this embodiment, semantic unit feature extraction is performed on the document parsing data. The document parsing data contains segmented text segments, image annotation regions, and their corresponding entity category labels. Using each text segment as the basic processing unit, a rule-based part-of-speech analysis method is employed to decompose the syntactic structure and identify key components such as noun phrases, verb phrases, quantifier phrases, and prepositional phrases. Each phrase is labeled with its semantic category, such as device name, operational behavior, physical state, or measurement parameters. For each image annotation region, the target attribute encoding data within the region is parsed to extract features of the target in terms of spatial dimension, shape boundary, grayscale distribution, and identification label. These text semantic components and image target information are combined into semantic units in a one-to-one correspondence, forming a record with the structure {text segment ID, image region ID, entity category, semantic category, syntactic label, spatial location}. In this step, a fixed set of syntactic rules (120 rules in total) is used to define the boundary judgment conditions for various semantic structures. All document segments are scanned item by item, and the matching results are extracted as semantic unit data according to the rules.

[0043] Step S162: Construct a knowledge representation vector based on the semantic unit data to obtain knowledge representation vector data;

[0044] In this embodiment, after obtaining the structured semantic unit data, a knowledge representation vector needs to be constructed for subsequent enhancement and comparison. For each semantic unit, the "subject-verb-object" triadic semantic combination is extracted and uniformly encoded into a triplet structure. Entity encoding uses a preset five-level hierarchical entity table for numbering, where the top-level entity is numbered from 1 to 99, and the numbering is extended to the fifth-level subclasses according to the hierarchy, ultimately ensuring that each entity has a unique integer number. Attribute and relation encoding uses a key-value mapping table, corresponding to descriptive adjectives, numerical parameters, operational verbs, or prepositions, etc., for a total of 210 commonly used semantic relations, each corresponding to a number from 1 to 210. Each knowledge representation vector ultimately forms a structure of {entity ID, attribute ID, relation ID, confidence score, text position, image coordinates}. The confidence score is calculated based on semantic structure completeness, entity semantic matching degree, and syntactic stability, with a score range of 0 to 1 and a precision of 0.001.

[0045] Step S163: Perform semantic enhancement based on the knowledge representation vector data to obtain semantically enhanced data;

[0046] In this embodiment, semantic enhancement processing is performed based on knowledge representation vector data. The system's built-in semantic extension rule set is loaded, containing approximately 3200 enhancement templates defined based on semantic mappings such as hierarchical relationships, parallel relationships, causal relationships, and temporal dependencies. Each knowledge representation vector is used as input, and enhancement conditions in the rule set are matched item by item. For example, when the entity in the recognition vector is "temperature sensor," the attribute is "rise," and the relationship is "monitoring," a template in the rule set is triggered: if the entity is a sensor and the relationship is the direction of rise, then the label "device malfunction" is added. After enhancement, the original knowledge representation vector adds an enhancement field, recording the added label, the enhancement rule ID, and the enhancement source evidence number. All semantic enhancement results are uniformly encoded to form extended knowledge vector data.

[0047] Step S164: Perform expert knowledge base matching based on semantic enhancement data to obtain expert knowledge base matching data;

[0048] In this embodiment, the matching process uses a three-layer indexing mechanism: the first layer quickly locates rules based on entity IDs; the second layer matches attribute ID values; and the third layer uses a semantic distance metric to calculate the cosine similarity between the enhanced relation field and the rule base definition relationship. A similarity threshold of 0.85 or higher is used to determine a successful match. The knowledge base ontology contains a fixed-format five-element rule structure: {entity ID, attribute range, relation category, semantic context vector, suggested tag}, with a total of 22,479 entries. All knowledge vector data enters the matching engine sequentially and is compared with each entry in the knowledge base. Upon a match, the rule ID and suggested tag of the knowledge base entry are returned, forming the final matching record and constituting the expert knowledge base matching data.

[0049] Step S165: Perform knowledge injection based on the matching data from the expert knowledge base to obtain knowledge injection data.

[0050] In this embodiment, a knowledge injection process is carried out based on the obtained expert knowledge base matching data. This process relies on a unified data encoding standard to convert each matching data entry into a standard RDF format triple. Each data entry includes a subject (i.e., entity ID), a predicate (i.e., relation ID), and an object (i.e., attribute value or enhanced tag), with an additional metadata field to record the matching rule ID, source location, and confidence score. The knowledge injection operation adopts a batch processing method, writing all RDF triples into a TTL file (Terse RDF Triple Language) of the knowledge graph management module, and registering the written content through the SPARQL query interface. The final result is a complete, uniformly numbered, and cross-queryable knowledge injection data, used for subsequent semantic detection and path reasoning operations.

[0051] Preferably, step S2 includes the following steps:

[0052] Step S21: Perform context feature awareness based on knowledge injection data to obtain context feature data;

[0053] In this embodiment, when performing the context feature awareness operation, knowledge injection data is first loaded in the form of an RDF structure triple set. Each knowledge triple is processed as a unit, and its original context position is extracted from the subject (entity ID), predicate (relation ID), and object (attribute value) of the triple. This includes original text position information (such as paragraph number, sentence position) and image coordinate information (such as bounding box center point position, region number). Based on the above position data, the preceding three text segments and the preceding two image regions are traced upwards, and their corresponding semantic unit information is extracted, including part-of-speech tags, semantic tags, time expressions, entity categories, operation verbs, and quantitative values. The extracted neighboring context semantic elements are encoded into fixed-length vectors to form a context semantic feature set. Fields include upstream and downstream entity names, operation verbs, time states, spatial position offsets, semantic tag IDs, and numerical attribute ranges. The time states are discretized at five levels (past, present, planned, long-term future, uncertain), and the position offsets are quantitatively represented using Euclidean distance (in pixels), with a control range of 0–500 pixels. All contextual semantic feature data are merged into a structured table to form a contextual feature dataset.

[0054] Step S22: Perform semantic association analysis based on contextual feature data to obtain semantic association data;

[0055] In this embodiment, records labeled with the same primary entity ID in all context feature data are grouped, and a timeline is constructed within each group, ordered from "past" to "future" based on their time status. Next, verb-like operations appearing more than twice in the relation ID field are searched within each timeline group, and their corresponding entity-relationship-attribute chains are extracted as potential semantic connection candidates. Furthermore, the overlap of semantic tag IDs between different context records is calculated; if the overlap exceeds 60%, semantic overlap is identified. Relative difference calculations are performed on the numerical parameters in the attribute fields based on the semantically overlapping records; if the relative change is greater than 25% and the direction is consistent, an attribute trend connection marker is added. Finally, logical connections are established based on three conditions: entity overlap, relation consistency, and attribute trend consistency. Context records satisfying two or more of these conditions are grouped into a semantic association cluster and encoded as a semantic association dataset.

[0056] Step S23: Perform deep semantic recognition based on semantic association data to obtain deep semantic data;

[0057] In this embodiment, deep semantic recognition is performed based on semantic association data. The specific process includes three stages: First, the co-occurrence relationships of entity categories in each semantic association cluster are extracted, and high-frequency entity combinations in the association cluster are counted, such as "motor-temperature-alarm" or "pump-pressure-decrease," etc., and an entity collaboration matrix is ​​constructed with a dimension of 500×500, corresponding to 500 basic entity categories. Second, the combination patterns of entity combinations and relationship types are analyzed. For each pair of entity relationship chains, the frequency of their occurrence in all semantic association clusters is counted, and the causal chain model of the operation sequence is performed in combination with the time state field of the context, such as the chain operation path of "temperature rises" → "fan turns on" → "current increases." Finally, a semantic structure graph is constructed based on the entity combination frequency, causal relationship path length, and attribute change trend direction. Each node represents an entity, the edge represents a relationship, and the direction indicates the order of operations. All logical chains of three layers and above are obtained by graph traversal and transformed into deep semantic data.

[0058] Of particular importance, step S23 includes the following steps:

[0059] Step S231: Extract the context sentence window based on the semantic association data to obtain context fragment data;

[0060] In this embodiment, pre-generated semantic association data is invoked, which records the semantic connections between entity pairs and their position numbers in the original text. Using the entity pairs involved in each semantic association as anchors, a context window extraction operation is performed. The context window size is set to two sentences before and after the sentence containing the current entity pair, with the window boundary not exceeding the same paragraph. Using sentence and paragraph numbers as index ranges, the corresponding text content is extracted from the original corpus data. All extracted text is uniformly encoded in UTF-8, and special characters and newlines are removed, standardizing it into continuous text segments. Each context segment data structure contains five fields: entity pair ID, starting sentence number, ending sentence number, text content, and original paragraph number, ultimately forming a context segment data table, which serves as input for subsequent part-of-speech analysis and syntactic structure processing.

[0061] Step S232: Perform part-of-speech tagging based on the context fragment data to obtain lexical structure data;

[0062] In this embodiment, word segmentation and part-of-speech tagging are performed on each context fragment data. A part-of-speech recognition process is constructed using a CRF (Conditional Random Field) sequence tagging algorithm, and bidirectional maximum matching is used for word processing. For each context fragment, word segmentation is performed, followed by part-of-speech tagging prediction, generating a sequence of words and part-of-speech tuples. The processing results are stored in a JSON structured format, with each record including fragment ID, word order number, term, part-of-speech category, and its position offset in the original text. All lexical structure data is stored in a temporary cache database for subsequent dependency parsing.

[0063] Step S233: Perform dependency parsing based on lexical structure data to obtain syntactic dependency chain data;

[0064] In this embodiment, a dependency syntactic tree generation algorithm based on rule sets is employed. For each part-of-speech tagging sequence of a context segment, word nodes are constructed sentence by sentence, and directional edges are established according to the grammatical collocation rules between adjacent words, forming a tree-like dependency graph structure. Dependency relations are stored in the form of triples: {modifier number, modified word number, relation type}, and each syntactic chain includes the minimum path distance between words (calculated by the difference in word order). All syntactic dependency chain data is uniformly encoded and sorted according to the original text segment number to form a complete syntactic dependency chain data table.

[0065] Step S234: Identify semantic role boundaries based on syntactic dependency chain data to obtain semantic role unit data; perform semantic paradigm matching based on semantic role unit data to obtain semantic intent number data;

[0066] In this embodiment, the action-centric word (verb class) is identified as the semantic focus based on syntactic dependency chain data, and the agent, patient, and modifier components of the verb are analyzed one by one. An action-driven role recognition mechanism is adopted, and according to the basic structural model of "agent-verb-patient," the subject connected to the verb in the dependency chain is determined to be the agent, the object to be the patient, and the adverbial to be the modifier. Each semantic unit includes fields such as action word, role type, term value, word position in the sentence, and dependency path. For the extracted semantic role units, a semantic paradigm library is called for matching. This paradigm library is based on the GB / T 18391-2021 semantic paradigm framework and contains approximately 200 typical semantic intent combinations. The matching method is role sequence matching and keyword overlap assessment (with an overlap threshold of 0.65). Upon successful matching, a corresponding semantic intent number is assigned. The generated data is recorded in a structured table, with fields including intent ID, action word, semantic paradigm type, role combination structure, etc., and the output is semantic intent number data.

[0067] Step S235: Aggregate semantic units based on semantic intent number data to obtain structured semantic aggregate data; encode and archive the structured semantic aggregate data and output it as deep semantic data.

[0068] In this embodiment, semantic intent ID data is grouped by segment number, and intent combinations of the same paradigm type are extracted. Semantic unit merging is performed on intent IDs within the same group, eliminating duplicate role structures and aggregating them into a unified semantic intent expression template. The template fields include action paradigm, participating entity encoding, role coverage, and frequency of occurrence. The merged aggregation result is encoded and archived. The encoding method uses SHA-256 digest encryption to uniquely identify the semantic template content, generating a 64-bit hexadecimal string encoding field. Each deep semantic data record includes a semantic ID, encoding identifier, semantic paradigm type, segment range, and archive timestamp. Finally, the deep semantic data is stored in a relational database, with each table holding a maximum of 10,000 aggregated semantic template records. Each record has a fixed structure and index fields for subsequent intelligent agent workflow configuration and scheduling.

[0069] Step S24: Perform implicit semantic detection based on deep semantic data to obtain implicit semantic data;

[0070] In this embodiment, potential paths between all nodes in the semantic structure graph that are not directly labeled in the original knowledge triples are statistically analyzed. For each entity-attribute combination in the path, a query is performed in the expert knowledge base to check if there are supplementary relationships with similar structures that are not explicitly labeled in the current data. If they exist, they are considered potential implicit semantic chains. At the same time, empty connection nodes (isolated entities without predecessors or successors) in the semantic structure graph are checked, and it is counted whether their context has ever contained boundary values ​​of adjacent relationships (such as numerical changes exceeding a set threshold of 15%). Nodes that meet the above conditions are labeled as "implicit causal nodes" or "abnormal triggering nodes". All cases of abnormal path structures, interrupted entity reasoning chains, and unexplained numerical mutations are classified as implicit semantic expressions, and their original knowledge triple numbers, supplementary semantic information, and implicit logical conditions are recorded to generate an implicit semantic dataset.

[0071] Of particular importance, step S24 includes the following steps:

[0072] Step S241: Extract semantic pointer chains based on deep semantic data to obtain semantic pointer chain data;

[0073] In this embodiment, deep semantic data is first loaded, which includes information such as semantic unit identifiers, semantic role boundaries, and syntactic dependency relationships. For each semantic unit, the text is scanned word by word based on a rule-matching algorithm to extract semantic pointing relationships, specifically identifying the pointing chains between verbs and their corresponding objects or modifiers. A directed graph structure is constructed, where nodes represent semantic units and edges represent pointing relationships. Edge weights are calculated by combining dependency syntactic distance and word frequency statistics, and a weighted threshold of 0.7 is used to filter valid pointing chains. This step uses a custom parsing program to parse the deep semantic data, relying on a fixed syntactic rule base and dictionary to ensure the accuracy of pointing chain construction. Finally, a semantic pointing chain data structure containing the start and end nodes of the links and the link weights is output.

[0074] Step S242: Extract context logic clues from semantic pointer chain data to obtain context logic clue data;

[0075] In this embodiment, for each pointing chain, a sliding window technique is used, with the window size set to 3 sentences. The sentences within the window serve as the context range. Logical clues between sentences are identified through regular expressions and key logical words matching (including more than 20 logical connectors such as "if," "then," "because," and "therefore"). Combining the weight information in the semantic pointing chain, a logical connection matrix is ​​established, and the similarity of matrix elements is calculated. A cosine similarity threshold of 0.65 is used to determine valid clues, generating a context logical clue data table. Fields include logical connectors, start and end sentence numbers, weight values, etc., for use in subsequent semantic reasoning stages.

[0076] Step S243: Perform cross-sentence semantic trigger word matching based on contextual logical clue data to obtain potential semantic trigger information;

[0077] In this embodiment, a semantic trigger word library is pre-constructed, containing approximately 1500 trigger words and phrases related to implicit semantics, such as "cause," "lead to," "due to," and "indicate." Sentence-by-sentence text scanning combined with regular expressions is used for matching, recording the sentence number and context of the trigger word's appearance. For consecutive sentences, the relevance of trigger words is verified based on word frequency statistics and word vector similarity (calculated using cosine similarity in the word vector space, with a threshold set to 0.7), filtering out potential semantic trigger information. The matching results form a dataset containing the trigger word text, sentence position, and semantic relevance score, providing input for constructing inference paths.

[0078] Step S244: Construct inference paths based on latent semantic triggering information to obtain implicit semantic relationship chain data;

[0079] In this embodiment, the reasoning path adopts a chain-like reasoning structure, which is recursively expanded through dependency relationships. Each path consists of multiple semantic nodes and trigger word links. During the construction process, the maximum path length is set to 5; paths exceeding this length are truncated. A graph traversal algorithm is used to start from the trigger word's initial node and extend along the semantic pointing chain. The node weights comprehensively consider syntactic dependency distance (threshold ≤ 3) and contextual logical weight (threshold ≥ 0.6). After the path is constructed, the path information is stored in a linked list structure, with fields including node sequence number, node semantic unit identifier, trigger word and its weight, and total path weight. This implicit semantic relationship chain data provides a structured foundation for subsequent inductive aggregation.

[0080] Step S245: Perform semantic induction and aggregation based on the implicit semantic relationship chain data to obtain implicit semantic data.

[0081] In this embodiment, all path lists are iteratively compared, and a similarity clustering algorithm (based on the Jaccard similarity coefficient, with a threshold of 0.75) is used to merge semantic relationship chains, reducing redundant links. During the aggregation process, common semantic nodes and repeated trigger words are extracted, and the weights are combined and weighted averaged to generate inductive semantic units. Finally, the aggregation results are converted into a standardized implicit semantic data format, with fields including inductive semantic unit identifier, associated path set, weighted weight, and text fragment mapping. The data is stored in a JSON structure for easy subsequent agent parsing and task scheduling.

[0082] Step S25: Construct a user requirement agent blueprint based on implicit semantic data; construct an agent workflow based on the user requirement agent blueprint;

[0083] In this embodiment, each implicit semantic chain contains a main entity (e.g., control device, electrical device, etc.) and multiple actions it drives. This main entity is considered a smart agent unit in the blueprint. Based on the action type and corresponding response attributes, each smart agent unit is mapped to a standard module component. These components include five categories: perception module, decision module, execution module, exception response module, and communication module. Each category has a fixed parameter template; for example, the perception module is bound to input types such as temperature and voltage, and the decision module executes actions such as frequency increase and load decrease. Multiple smart agent units are generated into a network structure according to the semantic chain connection order. All blueprint structures are organized in XML format, with fields including Agent_ID, Function_ID, Trigger_Type, Precondition, Action, and Output. Based on the logical connections between modules in the blueprint, a smart agent workflow is automatically constructed. Each workflow node is bound to an Agent_ID, and its pre- and post-dependencies are defined. A standard DAG (Directed Acyclic Graph) structure is output and stored as a JSON file, completing the smart agent workflow construction.

[0084] Step S26: Schedule task execution according to the agent workflow to obtain task execution data.

[0085] In this embodiment, each workflow node is parsed as a task scheduling unit, with fields including: task ID, input data type, required resource type (e.g., computing resources, sensor data), operation duration, priority level (1–5), and upstream / downstream dependent node IDs. The task nodes are then sorted according to the topology, and a greedy scheduling algorithm is used to traverse the entire task chain starting from the source node. While ensuring resource conflicts are avoided, high-priority nodes are prioritized for scheduling, and undependent tasks are processed in parallel as much as possible. A minimum load priority strategy is used in resource allocation; among currently idle resource nodes, the one with the lowest load is selected for task binding. The scheduling results are recorded in a scheduling log table, with fields including Task_ID, Start_Time, End_Time, Assigned_Node, and Upstream_Task, ultimately generating complete task execution data for subsequent topology construction operations.

[0086] Preferably, step S25 includes the following steps:

[0087] Step S251: Extract user statement intent features based on implicit semantic data to obtain user statement intent data;

[0088] In this embodiment, implicit semantic data includes text fragments, corresponding entity labels, potential causal relationships, and logical conditions. A text scanning method based on regular expressions is used to match a predefined keyword library of user intent within the text fragments. This keyword library contains approximately 3000 specific keywords and phrases, such as "request," "query," "control," and "monitor," with each keyword corresponding to a unique number. Subsequently, rule-based syntactic segmentation technology is used to subdivide the text fragments into basic semantic units, ensuring that the segmentation follows the linguistic rules of subject-verb-object structure. A dependency syntactic tree parsing algorithm is applied to each semantic unit to calculate the dependency relationships and word distances between words, identifying the core verb, the execution object, and its modifiers. Based on the parsing results, action category numbers (ranging from 0 to 99), object category numbers (ranging from 0 to 199), and modifier strength scores are extracted. Modifier strength is represented by floating-point numbers between 0 and 1, reflecting the degree of emphasis of the modifier. Simultaneously, combined with contextual information, timestamps and the start and end positions of sentences in the original text are recorded. All extracted intent features are aggregated in a structured manner to form a user statement intent data table containing fields such as intent ID, action encoding, object encoding, modification strength, and sentence start and end positions, which is used for subsequent semantic analysis and task execution process construction.

[0089] Step S252: Identify syntactic dependency relations based on user statement intent data to obtain syntactic dependency relation data;

[0090] In this embodiment, statistical syntactic analysis tools are used to segment the input text into syntactic components, obtaining part-of-speech tagging and phrase structure trees for sentence components. Then, dependency parsing algorithms (such as graph-based shortest path algorithms) are used to calculate dependency relations between words, including subject-verb, object-verb, and modifier-modified types. The dependency relation data includes relation type numbers (e.g., 1 represents subject-verb, 2 represents verb-object), the lexical IDs of the dependency headword and dependent words, dependency relation weights (ranging from 0.1 to 1.0, floating-point numbers), and the path length of the dependency chain. The resulting data is stored in a directed graph structure, with nodes representing lexical IDs and edges representing dependency relations, forming a syntactic dependency relation dataset.

[0091] Step S253: Fill the demand slots based on the syntactic dependency relation data to obtain structured demand slot data;

[0092] In this embodiment, a standardized requirement slot template is predefined. This template contains multiple slot categories, including action slots, target slots, time slots, and condition slots. Each slot has strictly defined field formats and data types. Action slots are specifically used to store action codes, with the encoding range limited to integers from 0 to 99. Target slots store object codes, with the encoding range limited to integers from 0 to 199. Time slots are designed to contain two fields, recording the start and end times respectively, in standard UTC time format with second-level precision. Condition slots store logical judgment expressions, stored as strings with a maximum character length of 256 characters. Based on a path analysis algorithm using syntactic dependency chains, the dependencies between actions and objects in the syntactic dependency chains are analyzed one by one. Action and object features are accurately located based on the dependency paths, and strict matching is performed according to the corresponding fields in the slot template. When action codes and object codes appear in the intent features, the corresponding values ​​are filled into the action and target slots. If a field does not find a valid match in the dependency relationship, a default null value is assigned to ensure data integrity. Time slots are filled by extracting timestamp information from the context and combining it with explicit or implicit time ranges in the text; slots without time information are left empty. Condition slots extract corresponding expressions based on logical conditions described in the text, truncate them to no more than 256 characters, and then fill them into the slots. All filled slot data is uniformly integrated according to slot name, filled content, filled confidence level, and data source number to form a structured requirement slot data table. The filled confidence level is calculated by a rule engine, with a value range limited to 0 to 1, reflecting the accuracy and reliability of the filled data. The data source number identifies the corresponding text or parsing module. Finally, the structured requirement slot data table is stored using a relational database table structure, supporting standard SQL query and update operations to ensure data access efficiency and accuracy in subsequent processing stages.

[0093] Step S254: Identify task types based on structured requirement slot data to obtain task identification data; bind capability modules based on task identification data to obtain capability module data; construct a user requirement intelligent agent blueprint based on capability module data.

[0094] In this embodiment, the task type library contains 500 predefined task types, each corresponding to a list of functional modules to be called. First, a unique mapping and matching process is performed on the codes of action slots and target slots in the requirement slots. An exact matching algorithm is used to search the task type library, with a matching threshold set to 100% perfect match. Only when the action code and target code simultaneously match the corresponding task type is the task type identified. The task identification data fields include task ID, task name, and matching degree. Subsequently, based on the task functional requirements corresponding to the task identification, the required modules are selected from the capability module library, which includes categories such as sensing modules, control modules, communication modules, and decision modules. Module binding is based on the required functional list of the task type, strictly matching the module number and version number. The binding information fields include module ID, module name, version number, and interface specification. All bound modules are integrated to form a capability module dataset, using JSON format to describe the interface and data flow relationships between modules, facilitating subsequent blueprint construction.

[0095] Step S255: Construct the agent workflow based on the agent blueprint of user requirements.

[0096] In this embodiment, blueprint construction first generates a directed acyclic graph (DAG) based on the functional dependencies between modules using graph theory. Nodes represent capability modules, and edges represent data and control flow between modules. Each node includes a module function description, input / output port definitions, interface protocol version, and processing latency parameters (in milliseconds). During construction, the data transmission path is ensured to be complete and loop-free based on the module's input dependencies, and the topological relationships between nodes are stored using an adjacency matrix. The blueprint data structure uses XML format, including module ID, function type, input interface, output interface, and dependencies. After the blueprint is completed, an agent workflow is automatically generated, transforming blueprint nodes into workflow task nodes. Each task node has its execution conditions, timeout (in seconds), and execution order defined. Finally, the agent workflow is stored in JSON file format, including task ID, dependencies, execution time budget, and resource requirements, for subsequent scheduling.

[0097] Preferably, step S3, which involves analyzing communication anomalies based on explicit node topology data, includes:

[0098] Real-time communication data is extracted based on explicit node topology data.

[0099] In this embodiment, explicit node topology information is imported, and this topology is stored in the form of a node list and a matrix of connections between nodes. The real-time communication data acquisition system uses a network packet capture tool, employing a timed polling method, to capture data packets for each communication link between nodes at 1-second intervals. The captured content includes the packet sequence number, timestamp, source node ID, target node ID, and packet size (in bytes). The captured data is stored in a high-speed cache database in time-series format, with data record fields including packet sequence number (integer), timestamp (accurate to milliseconds), source node identifier (string), target node identifier (string), and packet length (integer). Based on predefined node connection relationships, node pairs that meet the criteria are selected from the topology matrix, and communication data is collected for each node pair, achieving accurate extraction of real-time communication data.

[0100] Calculate the packet loss rate based on real-time communication data;

[0101] In this embodiment, the continuity of the collected data packet sequence numbers is detected, and the existence of packet loss events is determined based on the difference between sequence numbers. The calculation window is set to 1 minute, and the difference between the actual number of data packets received within this time window and the theoretical maximum sequence number that should be received is counted. The communication packet loss rate is calculated by dividing the difference between the actual number of received packets and the expected number of packets by the expected number of packets. The packet loss rate value is limited to the range of 0 to 1. The calculation result is updated every minute and stored in the time series database. The fields include node pair identifier, time window start time, and packet loss rate value. The packet loss rate threshold is set to 0.05. Time windows exceeding this threshold are marked as abnormal packet loss periods.

[0102] Based on the communication packet loss rate, the communication packet loss time period is statistically analyzed to obtain the communication packet loss rate time data;

[0103] In this embodiment, when performing the step of statistically analyzing communication packet loss time periods based on the packet loss rate, time windows with a packet loss rate exceeding 0.05 for more than one minute are merged to form continuous communication packet loss time periods. Each time period consists of a start time and an end time. All abnormal time periods are statistically analyzed to generate a communication packet loss rate time data set. This data set is stored in tabular form, with fields including start time (UTC time format, accurate to the second), end time, node pair identifier, and peak packet loss rate. This table supports querying by time order and node pairs, ensuring accurate retrieval of abnormal time periods in subsequent analysis steps.

[0104] Calculate the packet out-of-order rate based on real-time communication data;

[0105] In this embodiment, in the step of calculating the out-of-order rate of data packets based on real-time communication data, the deviation between the arrival order and the sending sequence number of data packets is analyzed for each node pair's communication data. An out-of-order event is defined as a situation where the sequence number of a later-arriving data packet is less than the sequence number of an earlier-arriving data packet. The number of out-of-order events per minute is counted against the total number of received data packets. The out-of-order rate is calculated by dividing the number of out-of-order events by the total number of received packets, with a value ranging from 0 to 1. This calculation is performed once per minute and stored in a time-series database. The recorded fields include the node pair identifier, the start time of the time window, and the out-of-order rate. An out-of-order rate threshold of 0.03 is set; time windows exceeding this threshold are considered abnormal out-of-order periods.

[0106] Based on the out-of-order data rate statistics and the out-of-order time period of the data packets, we obtain the out-of-order time data of the data packets.

[0107] In this embodiment, time windows with an out-of-order rate exceeding 0.03 for one minute or more are merged to generate continuous out-of-order time periods. Each time period is defined by a start time and an end time, forming a data set of out-of-order data packets. This set is stored in a standard table format, with fields including start time, end time, node pair identifier, and peak out-of-order rate, supporting retrieval based on time and node pairs.

[0108] The communication transmission anomaly data is obtained by performing a time intersection operation on the communication packet loss rate time data and the data packet out-of-order time data.

[0109] In this embodiment, time period overlap analysis is performed on two time data sets. A time interval cross-calculation algorithm is used to calculate the intersection interval of the packet loss time period and the out-of-order time period. The length of the intersection interval must be greater than or equal to 30 seconds to be included in the valid abnormal time period. In this way, communication abnormal time periods that simultaneously exhibit packet loss and out-of-order delivery are filtered out, generating a communication transmission abnormal data set. This data set is stored as a time period list, with fields including the start and end times of the abnormal time, the identifiers of the involved node pairs, and the duration of the abnormality, for subsequent anomaly detection.

[0110] Node communication jitter anomaly detection is performed based on abnormal communication transmission data to obtain abnormal node communication data.

[0111] In this embodiment, previously obtained communication transmission anomaly data is retrieved. This data includes the start and end times of multiple abnormal time periods, as well as the corresponding node pair identifiers. For each abnormal time period, the arrival timestamp sequence of all communication data packets passing through that node pair within that time period is extracted, with timestamps accurate to milliseconds. The calculation process uses the arrival time interval of adjacent data packets within that time period as the basic unit, specifically subtracting the arrival time of the previous packet from the arrival time of the next packet, forming a time interval sequence. Subsequently, the standard deviation of this time interval sequence is calculated as a communication latency jitter index. The standard deviation calculation uses an unbiased estimation method, with the degrees of freedom in the formula equal to the sample size minus one, ensuring the statistical reasonableness of the calculation results. The time window strictly corresponds to the start and end times of the abnormal time period to avoid confusion across time periods. Jitter values ​​are stored in milliseconds, recorded with accuracy to three decimal places. A threshold of 50 milliseconds is set; jitter values ​​exceeding this threshold are marked as abnormal. The threshold is derived from network communication standards and actual measurement experience, and can effectively reflect the latency fluctuations of the communication link. Each abnormal time period's calculation result includes a node pair identifier, the start and end times of the abnormal time period, the calculated jitter value, and a jitter abnormality status flag (Boolean, 1 for abnormal, 0 for normal). All results are aggregated to form a node communication abnormality dataset. The data structure uses a relational table and supports retrieval by time, node pair, and abnormal status. This dataset not only records the abnormal time periods but also reflects the specific numerical changes in jitter, providing accurate quantitative indicators and anomaly alarms for subsequent network maintenance, link optimization, and node resource scheduling.

[0112] Preferably, step S3, which identifies abnormal communication links based on abnormal node communication data, includes:

[0113] Duplicate request analysis is performed based on node communication anomaly data to obtain duplicate request anomaly access data.

[0114] In this embodiment, key fields for each communication record are extracted from the node communication anomaly data, including the request source IP address, destination IP address, request type identifier, request timestamp, and request sequence number. For the extracted data, a hash table-based index structure is established to map identical request identifiers (composed of source IP, destination IP, and request type) to corresponding time series lists. A time window of 60 seconds is set, and the number of times the same request identifier appears for all requests within this time window is calculated. If the same request identifier appears more than 5 times within the time window, it is determined to be a duplicate request anomaly. Duplicate request anomaly access data is stored in a structured table format, with fields including request identifier, time window start and end times, number of duplicate requests, and request summary information. The storage format is a relational database table for easy subsequent querying and analysis.

[0115] Based on the abnormal access data of repeated requests, access surge statistics are obtained to obtain access surge data;

[0116] In this embodiment, the access traffic data for each node is divided into time periods, with a fixed time period length of 10 seconds. For each time period, the total number of requests received by that node is counted to form time-series access data. A sliding window algorithm is used, with a sliding window length of 6 time periods (i.e., 60 seconds). The ratio of the number of accesses in the current time period to the average number of accesses in the past 5 time periods within the sliding window is calculated. When the ratio exceeds 3, the current time period is marked as an access surge period. Access surge data is stored with the start and end times of the time period, node identifier, total number of accesses, and surge ratio fields, in a time-series database standard format, supporting efficient retrieval and statistics.

[0117] Denial-of-service attack detection is performed based on sudden surges in access data to obtain denial-of-service attack data.

[0118] In this embodiment, for each time period marked as a surge in access, the total number of requests and the percentage of duplicate requests within that time period are calculated. A denial-of-service (DoS) attack threshold is set as a total number of requests exceeding 1000 per unit time and a duplicate request ratio exceeding 20%. Time periods meeting these conditions are identified as DoS attack events. DoS attack data includes the start and end times of the attack period, affected node identifiers, total number of requests, duplicate request ratio, and event status flags, and is stored in a structured security event log format.

[0119] Intrusion behavior detection is performed based on denial-of-service attack data to obtain intrusion behavior data;

[0120] In this embodiment, the source IP address information of all requests during a denial-of-service attack is collected, and the source IPs are matched using a pre-built blacklist IP database. The blacklist database contains over 100,000 malicious IP addresses, and the matching operation uses a hash index for fast retrieval. If a blacklist IP accesses the site during the denial-of-service attack period, an intrusion event is generated. The intrusion event data fields include the intrusion event time, node identifier, attack source IP address, intrusion type identifier, and blacklist database entry number, and are stored in a Security Information and Event Management (SIEM) system compatible format.

[0121] Based on the statistical analysis of intrusion behavior data, communication link protocol identification is performed to obtain communication link protocol data;

[0122] In this embodiment, all network data packets within the time window of the intrusion event are collected, and the protocol type field, such as TCP, UDP, HTTP, HTTPS, etc., is extracted. The data packets are classified and statistically analyzed according to protocol, and the percentage of data packets and bytes transmitted for each protocol is calculated. Protocol types with a percentage exceeding 50% are recorded as primary protocols. The communication link protocol data fields include the start and end times of the time window, node pair identifier, protocol type, and protocol percentage. The data is presented in a structured protocol analysis report format.

[0123] Version anomaly analysis is performed based on communication link protocol data to obtain protocol version anomaly data;

[0124] In this embodiment, the protocol version field, such as the TLS version number and HTTP protocol version, is extracted first. A version whitelist is established, containing all normally allowed protocol versions. The frequency of each version within a time window is statistically analyzed; version numbers below 1% or not in the whitelist are marked as abnormal versions. If an abnormal version occurs more than 10 times, it is recorded as a version anomaly event. Protocol version anomaly data includes the time window, node pair identifier, protocol type, abnormal version number, and number of occurrences, formatted according to the security event log standard.

[0125] Abnormal communication links are identified based on abnormal protocol version data, and abnormal communication link data is obtained.

[0126] In this embodiment, all version-specific anomaly events are comprehensively analyzed, and anomaly versions that occur consecutively for more than three time windows are filtered out. The number of anomaly node pairs involved is also counted. If the number of anomaly node pairs exceeds two and the consecutive occurrence of the anomaly version exceeds 30 seconds, the link is determined to be an anomaly communication link. The anomaly communication link data includes the link's start and end nodes, the start and end of the anomaly time period, details of the anomaly version, and link status markers. It adopts a network topology anomaly report format to provide data support for subsequent network security protection and node resource scheduling.

[0127] Preferably, step S3, which involves scheduling node resources based on abnormal communication link data, includes:

[0128] Node resource status data is obtained by statistically analyzing node resource status based on abnormal communication link data.

[0129] In this embodiment, the identification information of all involved nodes is extracted from the abnormal communication link data. This is combined with the resource usage data of each node collected by the real-time monitoring system, including indicators such as CPU utilization (percentage, ranging from 0 to 100), memory usage (in MB), network bandwidth utilization (percentage), disk I / O latency (in milliseconds), and node queue length. The data collection frequency is set to once per second, and the statistical period is the data within the most recent five minutes. Time series analysis is performed on the resource data of each node to calculate statistics such as mean, maximum, and standard deviation. The above indicators are aggregated by node to generate a node resource status data table. Fields include node ID, mean CPU utilization, mean memory usage, maximum bandwidth utilization, average disk I / O latency, and mean queue length. This table is stored in a relational database for subsequent analysis.

[0130] Based on the node resource status data, the resource bottleneck node is identified, and the bottleneck node data is obtained.

[0131] In this embodiment, bottleneck determination is performed on the resource status data of all nodes. Specific thresholds are set: CPU utilization exceeding 85%, memory usage exceeding 90% of total capacity, network bandwidth utilization exceeding 80%, disk I / O latency exceeding 50 milliseconds, and queue length exceeding 100 entries are considered resource stress indicators. For each node, each indicator is checked to see if it exceeds the threshold, and the number of exceeding indicators is counted. The node with the most exceeding indicators and the most severe exceeding (e.g., CPU utilization exceeding 95% or memory usage exceeding 95%) is identified as the bottleneck node. Bottleneck node data includes node ID, type of exceeding resource, actual value of each resource indicator, and exceeding level (mild, moderate, severe). The data format is structured table storage, supporting filtering and sorting operations.

[0132] Task migration data is obtained by performing task migration analysis based on bottleneck node data.

[0133] In this embodiment, a list of tasks to be migrated is determined. Each task includes its task ID, resource requirements (CPU core count, memory size, network bandwidth requirements), and the ID of the node where the task is currently located. Tasks on high-load nodes are filtered out using bottleneck node data. The resource status of the target node after task migration is analyzed. The target node must meet the task resource requirements and its resource utilization rate must be below the corresponding thresholds (CPU below 70%, memory below 75%). The task migration analysis uses an exhaustive method to traverse the target node list, calculating the resource matching degree and load balancing index for each migration scheme. The task migration data is output, including the task ID, source node ID, target node ID, resource matching score, and load balancing improvement value. The results are stored as a list of task migration schemes.

[0134] The migration communication overhead is calculated based on the task migration data to obtain migration communication overhead data.

[0135] In this embodiment, the data volume (in MB) and estimated migration time (in seconds) involved in the task migration process are first obtained. The data volume is derived from the task memory snapshot size and the amount of dependent file transfers. Communication bandwidth data is obtained from the target node's network bandwidth utilization and maximum bandwidth value. The communication overhead calculation formula is: Migration communication overhead = Data volume / Available bandwidth, in seconds. Considering network latency, the average latency over the past five minutes is used as the benchmark, in milliseconds, converted to seconds and added to the migration time. The final migration communication overhead data includes the task ID, migration start and end nodes, data volume, bandwidth rate, network latency, and total communication overhead value. The data format is a structured report for easy sorting and filtering.

[0136] Node scheduling path data is obtained by analyzing the migration communication overhead data.

[0137] In this embodiment, a graph traversal-based path search algorithm is employed, utilizing the communication topology graph and task dependencies, to traverse all scheduled paths from the source node to the target node. The communication cost of each path is the sum of the communication costs between all nodes on the path. A maximum allowable communication cost threshold of 30 seconds is set, filtering out paths exceeding this threshold. For paths meeting the threshold, the path load balancing score and fault risk level (based on historical communication anomaly rates) are calculated. Finally, the node scheduling path data records the path ID, node sequence, total communication cost, load balancing score, and fault risk score, and are stored in the path database.

[0138] Node resource scheduling is performed based on node scheduling path data to obtain node resource scheduling data.

[0139] In this embodiment, the path with the lowest communication overhead and highest load balancing is selected as the priority scheduling path based on the scheduling path data. Combined with bottleneck node information, task allocation is adjusted, prioritizing tasks for non-bottleneck nodes or nodes with lower loads. During scheduling, node resource status is updated in real time, and the node task load ratio is adjusted to ensure that node resource utilization remains within a safe range. Node resource scheduling data includes node ID, allocated task list, task resource usage details, current resource utilization, and scheduling timestamp, recorded in a structured log format to provide accurate node load information for the agent's decision-making path optimization.

[0140] Preferably, step S4 includes the following steps:

[0141] Step S41: Extract node status features based on node resource scheduling data to obtain scheduling node status data;

[0142] In this embodiment, node status features are extracted from node resource scheduling data. Node resource scheduling data includes each node's CPU utilization (percentage, 0-100%), memory usage (in MB), network bandwidth utilization (percentage), disk read / write speed (MB / s), current task queue length (integer number of tasks), node response time (in milliseconds), and node error rate (percentage) during the scheduling process. By collecting time-series data at 1-second intervals and using a 5-minute sliding time window, the statistical characteristics of each indicator are calculated, including mean, maximum, minimum, and standard deviation, which serve as input parameters for the node status features. For abnormal indicators, such as error rates greater than 2% or response times exceeding 500ms, an abnormal status field is additionally marked. All feature fields are integrated according to node ID to form a structured scheduling node status dataset. The fields are stored in tabular form, including node identifier, mean, peak, fluctuation range, and abnormal status markers for each resource indicator.

[0143] Step S42: At the macro level, a reinforcement learning algorithm is used to predict the path to achieve long-term business goals based on the status data of scheduling nodes, and a quarterly optimization strategy at the macro level is generated.

[0144] In this embodiment, a reinforcement learning algorithm is applied based on the scheduling node state data to predict the path to the quarterly business target. The state space is composed of the node state feature vectors from step S41, and the action space is defined as a set of node resource scheduling strategies, including resource priority adjustment, load allocation ratio adjustment, etc. The reward function is set with the system throughput (unit: number of tasks / second), average response time (milliseconds), and resource utilization rate (percentage) as evaluation indicators within the quarter, with comprehensive weighting coefficients of 0.5, 0.3, and 0.2, respectively. A discount factor γ=0.95 is used, and the most recent 50,000 state-action-reward records are stored using an experience replay mechanism during training. The target network parameters are updated synchronously every 1,000 steps. The reinforcement learning model uses a value function approximation method, processes the input state through a deep neural network, and outputs the optimal action strategy. The model output is a quarterly optimization strategy file, which includes a list of resource scheduling priorities between nodes and a resource allocation ratio matrix, and is saved in standard JSON format for subsequent use.

[0145] Step S43: At the tactical layer, the near-end strategy optimization algorithm is used to configure the workflow nodes based on the scheduling node status data, generating tactical layer configuration data;

[0146] In this embodiment, the Proximal Policy Optimization (PPO) algorithm is applied to configure workflow nodes based on the scheduling node status data. The status input consists of node resource status characteristics and current workflow task status information. The action space is defined as node task allocation, task start order adjustment, and load balancing parameter settings. Training parameters include a shearing coefficient ε = 0.2, a learning rate of 0.0003, and a batch size of 64. A multilayer perceptron network structure is used, containing two hidden layers with 256 and 128 nodes respectively, and the activation function is ReLU. A multi-threaded environment is used during training to accelerate sample acquisition and ensure the timeliness of policy updates. The output is tactical layer configuration data, in a format including a task allocation table, workflow execution order, and node load thresholds, saved as a relational database record for easy real-time retrieval and updating by the scheduling system.

[0147] Step S44: In the execution layer, a deep Q-network is applied to adjust the API order of the scheduling node state data and generate execution layer configuration data;

[0148] In this embodiment, a Deep Q-Network (DQN) is applied to adjust and optimize the API call order in the scheduling node state data. The input state includes the node's current task execution state, API call queue, and historical call delay data. The action space is an adjustable sequence of API call orders. The reward function is designed to minimize the total task completion time and maximize the API call success rate, with weight ratios of 0.7 and 0.3. The experience replay buffer capacity is set to 10,000 records, and in the ε-greedy policy, ε decays linearly from 1.0 to 0.1. The target network is updated every 1,000 steps. The neural network contains three fully connected layers with 512, 256, and 128 nodes, respectively, and the activation function is ReLU. After training, the output is the execution layer configuration data, specifically the API call order adjustment scheme, with timestamps and expected response times, stored in a structured form format for easy access by the scheduling execution module.

[0149] Step S45: Construct a reinforcement learning decision engine based on the macro-level quarterly optimization strategy, tactical-level configuration data, and execution-level configuration data;

[0150] In this embodiment, a reinforcement learning decision engine is constructed by integrating quarterly optimization strategies at the macro level, configuration data at the tactical level, and configuration data at the execution level. First, the data from the three levels is standardized, unifying field formats and units, and numerical fields are processed using Z-score normalization. A weighted fusion algorithm is then used to merge the policy parameters from each level, with weights allocated as follows: macro level 0.5, tactical level 0.3, and execution level 0.2. These weights are periodically adjusted based on historical scheduling performance feedback. The fusion result forms a multi-level set of decision parameters, which is input to the core module of the decision engine. This module includes three sub-modules: state evaluation, action selection, and policy execution, supporting real-time data input and online policy fine-tuning. The decision engine outputs a multi-agent coordinated scheduling scheme, formatted as node task paths, resource allocation ratios, and scheduling priorities, and saves it as an executable scheduling instruction set, supporting dynamic scheduling system calls.

[0151] Step S46: Optimize the multi-agent decision path using the reinforcement learning decision engine to obtain decision path optimization data.

[0152] In this embodiment, based on the input scheduling strategy and node status, a path search algorithm combined with reinforcement learning is used to dynamically plan the task path for each agent, considering inter-node communication latency (range 0-200ms), resource load threshold (not exceeding 80% CPU utilization), and task priority (value 1-10). Path adjustments are based on real-time feedback, with an adjustment cycle of 5 seconds. Path data is transmitted efficiently through an incremental update mechanism. The output decision path optimization data includes agent node ID, task path sequence, resource allocation ratio, and estimated completion time (seconds), stored in JSON format, supporting integration with scheduling execution systems to achieve collaborative and efficient operation of multi-agent systems.

[0153] Preferably, step S46 includes the following steps:

[0154] Step S461: Extract decision weight parameters based on the reinforcement learning decision engine to obtain the engine decision weight parameters;

[0155] In this embodiment, the weight matrix file accessed through the decision engine contains the weight values ​​of each layer in the network. The weight values ​​are represented as floating-point numbers, ranging from -1.0 to 1.0, with precision retained to six decimal places. The weight parameters include state input weights, action output weights, and hidden layer connection weights. The weight matrix is ​​analyzed layer by layer using a matrix parsing tool to extract the weight parameters for key indicators such as node resource utilization, task priority, and communication latency. The weight parameters are normalized using a max-min normalization method, linearly mapping the weight values ​​to between 0 and 1. The weight extraction results are saved in a structured array format, with fields including weight name, layer index, and normalized value, forming the engine decision weight parameter dataset for easy use in subsequent policy network model construction.

[0156] Step S462: Construct a policy network model based on the engine decision weight parameters, and perform decision reasoning operations based on the policy network model to obtain decision reasoning data;

[0157] In this embodiment, the number of layers, the number of nodes per layer, and the activation function type of the policy network are determined based on the weight parameters. The network structure adopts a three-layer fully connected structure. The number of nodes in the input layer corresponds to the dimension of the input state features, and the middle two layers are set to 128 and 64 nodes respectively. The activation function is ReLU. The number of nodes in the output layer is the same as the size of the action space, and Softmax activation is used to output the decision probability distribution. During network parameter initialization, the corresponding connection weights are assigned using the weight parameters normalized in step S461. Subsequently, the decision inference operation of the policy network is executed. The input is the current system state feature vector, including node load rate (percentage, 0-100), task urgency (1-10 integers), and communication latency (milliseconds). The output action probability is calculated through forward propagation. The inference result includes the probability value of each action, which is saved as decision inference data. The data format is a two-dimensional floating-point array containing action IDs and corresponding probabilities, supporting dynamic scheduling system calls.

[0158] Step S463: Perform temporal conflict detection on the agent based on the decision reasoning data to obtain conflict-labeled path data;

[0159] In this embodiment, task time window information and action time sequences are used to detect time overlap and resource contention conflicts between tasks of different agents. Specifically, a time sequence graph is constructed to map the task execution time period of each agent to a time interval, and overlapping intervals are detected. A conflict threshold is set; a time overlap exceeding 50 milliseconds is considered a conflict. Conflict labels are recorded for all conflicting task pairs, including agent ID, conflicting task ID, start and end times of the conflicting time period, and conflicting resource type (CPU, memory, communication link). Conflict label path data is stored in tabular form, with fields including path ID, task sequence, conflict flag, and conflict level (integer from 1 to 5, with 1 being the lowest), for subsequent conflict resolution scheduling.

[0160] Step S464: Rank the decision priorities based on the conflict-annotated path data to obtain decision priority data;

[0161] In this embodiment, the sorting rule adopts a multi-factor weighted method, with weight coefficients including task urgency (0.4), conflict severity (0.35), and historical task execution success rate (0.25). Task urgency is based on scheduling input parameters, conflict severity is based on conflict level values, and execution success rate is calculated statistically from historical scheduling records, ranging from 0 to 1. Priority scores are calculated for all conflicting paths according to the above weighted scores, with higher scores indicating higher priority. The sorting result is output as a priority list, including task ID, agent ID, priority score, and sorting sequence number, and saved as a structured data file (CSV format), supporting real-time access and adjustment by the scheduling system.

[0162] Step S465: Optimize the multi-agent decision path based on the decision priority data to obtain the decision path optimization data.

[0163] In this embodiment, task execution paths for each agent are planned according to priority, combined with node resource status and communication link topology information. Path planning considers node load limitations (not exceeding 85% CPU utilization), link bandwidth limitations (minimum 100Mbps), and inter-task dependencies. A constrained depth-first search algorithm is used for path search to ensure that high-priority tasks receive optimal node and time period resource allocation, while avoiding conflicts with other agents. The path optimization output includes agent ID, task sequence, node allocation scheme, time node mapping, and resource allocation ratio. The final decision path optimization data is stored in JSON format, with fields covering agent identifier, path node list, execution timestamp, and resource usage details, for use by the scheduling and execution module to achieve efficient coordinated operation of the multi-agent system.

[0164] Therefore, the embodiments should be considered as exemplary and non-limiting in all respects, and the scope of the invention is defined by the appended claims rather than the foregoing description. Thus, all variations falling within the meaning and scope of the equivalents of the application are intended to be included within the invention.

[0165] The above description is merely a specific embodiment of the present invention, enabling those skilled in the art to understand or implement the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the present invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features of the invention herein.

Claims

1. A method for optimizing agent decision-making paths that integrates explicit topology and implicit semantics, characterized in that, Includes the following steps: Step S1: Acquire multimodal data; Document parsing is performed based on multimodal data to obtain document parsing data; Knowledge injection is performed based on the document parsing data to obtain knowledge injection data; Step S2: Perform implicit semantic detection based on the knowledge injection data to obtain implicit semantic data; construct a user requirement intelligent agent blueprint based on the implicit semantic data; Build intelligent agent workflows based on user-defined intelligent agent blueprints; Based on the agent workflow, task execution scheduling is performed to obtain task execution data. Step S2 includes the following steps: Step S21: Perform context feature awareness based on knowledge injection data to obtain context feature data; Step S22: Perform semantic association analysis based on contextual feature data to obtain semantic association data; Step S23: Perform deep semantic recognition based on semantic association data to obtain deep semantic data; Step S24: Perform implicit semantic detection based on deep semantic data to obtain implicit semantic data; Step S25: Construct a user requirement agent blueprint based on implicit semantic data; construct the agent workflow based on the user requirement agent blueprint. Step S25 includes the following steps: Step S251: Extract user statement intent features based on implicit semantic data to obtain user statement intent data; Step S252: Identify syntactic dependency relations based on user statement intent data to obtain syntactic dependency relation data; Step S253: Fill the demand slots based on the syntactic dependency relation data to obtain structured demand slot data; Step S254: Identify task types based on structured requirement slot data to obtain task identification data; bind capability modules based on task identification data to obtain capability module data; construct a user requirement intelligent agent blueprint based on capability module data. Step S255: Construct the agent workflow based on the user-defined agent blueprint; Step S26: Schedule task execution according to the agent workflow to obtain task execution data; Step S3: Construct explicit node topology based on task execution data to obtain explicit node topology data; perform communication anomaly analysis based on explicit node topology data to obtain node communication anomaly data; identify abnormal communication links based on node communication anomaly data to obtain abnormal communication link data; perform node resource scheduling based on abnormal communication link data to obtain node resource scheduling data. Step S4: Construct a reinforcement learning decision engine based on node resource scheduling data; optimize the decision path of multiple agents based on the reinforcement learning decision engine to obtain decision path optimization data.

2. The agent decision-making path optimization method integrating explicit topology and implicit semantics according to claim 1, characterized in that, Step S1 includes the following steps: Step S11: Acquire multimodal data and perform data preprocessing to obtain multimodal data to be processed; Step S12: Identify text regions based on the multimodal data to be processed to obtain text region data; perform semantic segmentation based on the text region data to obtain semantic segmentation data; perform document slicing based on the semantic segmentation data to obtain document slice data; Step S13: Perform image segmentation based on the multimodal data to be processed to obtain image segmentation region data; perform target detection based on the image segmentation region data to obtain image target data; perform target attribute recognition based on the image target data to obtain target attribute data; Step S14: Perform vectorization encoding on the document slice data to obtain semantic vector data; perform feature encoding on the target attribute data to obtain target attribute encoded data; Step S15: Perform multimodal alignment processing based on semantic vector data and target attribute encoding data to obtain multimodal aligned data; perform semantic parsing based on multimodal aligned data to obtain document parsing data; Step S16: Perform knowledge injection based on the document parsing data to obtain knowledge injection data.

3. The agent decision-making path optimization method integrating explicit topology and implicit semantics according to claim 2, characterized in that, Step S16 includes the following steps: Step S161: Extract semantic unit features from the document parsing data to obtain semantic unit data; Step S162: Construct a knowledge representation vector based on the semantic unit data to obtain knowledge representation vector data; Step S163: Perform semantic enhancement based on the knowledge representation vector data to obtain semantically enhanced data; Step S164: Perform expert knowledge base matching based on semantic enhancement data to obtain expert knowledge base matching data; Step S165: Perform knowledge injection based on the matching data from the expert knowledge base to obtain knowledge injection data.

4. The agent decision-making path optimization method integrating explicit topology and implicit semantics according to claim 1, characterized in that, Step S3, which involves analyzing communication anomalies based on explicit node topology data, includes: Real-time communication data is extracted based on explicit node topology data. Calculate the packet loss rate based on real-time communication data; Based on the communication packet loss rate, the communication packet loss time period is statistically analyzed to obtain the communication packet loss rate time data; Calculate the packet out-of-order rate based on real-time communication data; Based on the out-of-order data rate statistics and the out-of-order time period of the data packets, we obtain the out-of-order time data of the data packets. The communication transmission anomaly data is obtained by performing a time intersection operation on the communication packet loss rate time data and the data packet out-of-order time data. Node communication jitter anomaly detection is performed based on abnormal communication transmission data to obtain abnormal node communication data.

5. The agent decision-making path optimization method integrating explicit topology and implicit semantics according to claim 1, characterized in that, Step S3, which identifies abnormal communication links based on abnormal node communication data, includes: Duplicate request analysis is performed based on node communication anomaly data to obtain duplicate request anomaly access data. Based on the abnormal access data of repeated requests, access surge statistics are obtained to obtain access surge data; Denial-of-service attack detection is performed based on sudden surges in access data to obtain denial-of-service attack data. Intrusion behavior detection is performed based on denial-of-service attack data to obtain intrusion behavior data; Based on the statistical analysis of intrusion behavior data, communication link protocol identification is performed to obtain communication link protocol data; Version anomaly analysis is performed based on communication link protocol data to obtain protocol version anomaly data; Abnormal communication links are identified based on abnormal protocol version data, and abnormal communication link data is obtained.

6. The agent decision-making path optimization method integrating explicit topology and implicit semantics according to claim 1, characterized in that, Step S3, which involves scheduling node resources based on abnormal communication link data, includes: Node resource status data is obtained by statistically analyzing node resource status based on abnormal communication link data. Based on the node resource status data, the resource bottleneck node is identified, and the bottleneck node data is obtained. Task migration data is obtained by performing task migration analysis based on bottleneck node data. The migration communication overhead is calculated based on the task migration data to obtain migration communication overhead data. Node scheduling path data is obtained by analyzing the migration communication overhead data. Node resource scheduling is performed based on node scheduling path data to obtain node resource scheduling data.

7. The agent decision-making path optimization method integrating explicit topology and implicit semantics according to claim 1, characterized in that, Step S4 includes the following steps: Step S41: Extract node status features based on node resource scheduling data to obtain scheduling node status data; Step S42: At the macro level, a reinforcement learning algorithm is used to predict the path to achieve long-term business goals based on the status data of scheduling nodes, and a quarterly optimization strategy at the macro level is generated. Step S43: At the tactical layer, the near-end strategy optimization algorithm is used to configure the workflow nodes based on the scheduling node status data, generating tactical layer configuration data; Step S44: In the execution layer, a deep Q-network is applied to adjust the API order of the scheduling node state data and generate execution layer configuration data; Step S45: Construct a reinforcement learning decision engine based on the macro-level quarterly optimization strategy, tactical-level configuration data, and execution-level configuration data; Step S46: Optimize the multi-agent decision path using the reinforcement learning decision engine to obtain decision path optimization data.

8. The agent decision-making path optimization method integrating explicit topology and implicit semantics according to claim 7, characterized in that, Step S46 includes the following steps: Step S461: Extract decision weight parameters based on the reinforcement learning decision engine to obtain the engine decision weight parameters; Step S462: Construct a policy network model based on the engine decision weight parameters, and perform decision reasoning operations based on the policy network model to obtain decision reasoning data; Step S463: Perform temporal conflict detection on the agent based on the decision reasoning data to obtain conflict-labeled path data; Step S464: Rank the decision priorities based on the conflict-annotated path data to obtain decision priority data; Step S465: Optimize the multi-agent decision path based on the decision priority data to obtain the decision path optimization data.

Images