A policy intelligent matching system based on a knowledge graph

Abstract

This invention relates to a knowledge graph-based intelligent policy matching system, specifically in the field of natural language processing. By deeply integrating multi-source heterogeneous data with the topological association of the knowledge graph, it achieves deep semantic understanding and accurate matching between policy provisions and enterprise profiles. The generated matching results are not only highly accurate and personalized, but also provide traceable key evidence, significantly improving the reliability of policy recommendations and the efficiency of application. At the same time, with the help of a federated learning framework, it can continuously absorb data experience scattered in various places while strictly protecting data privacy, enabling the model to continuously evolve and adapt to diverse regional and industry scenarios. This not only enhances the sense of gain for enterprises, but also helps to achieve better allocation of policy resources.

Description

Technical Field

[0001] This invention relates to the field of natural language processing, and more specifically, to a policy intelligent matching system based on knowledge graphs. Background Technology

[0002] In the agricultural product processing industry, various business entities often need to actively search for and apply for special support policies issued by governments at all levels to obtain subsidies, tax breaks, or project support. However, policy information is usually scattered in the form of unstructured official documents on the websites or databases of various functional departments. The text content is highly professional, the clauses are strictly worded, and there are many implicit conditions. For example, the criteria for identifying "micro and small enterprises" may vary slightly in policy documents at different provincial and municipal levels, while industry-oriented requirements such as "technological transformation" and "green development" are closely related to the specific characteristics of enterprises' actual production equipment, processes, energy consumption, and emissions. Enterprise users, especially small and medium-sized enterprises, face huge information screening and judgment costs when they try to understand and match policies on their own. The current common solution is to establish a policy document database and provide keyword search function, or to push policies based on simple tag classification. These methods essentially rely on the matching of surface words and cannot understand the internal logic, applicable boundaries, and deep semantic connections between policy provisions and the multi-dimensional profile of enterprises, resulting in a significant "semantic gap" between policy information and enterprise needs.

[0003] In existing technologies, methods aimed at achieving intelligent policy matching mostly rely on rule-based expert systems or traditional machine learning classification models. Rule-based systems require manually pre-defining a large number of "IF-THEN" logical rules to map policy conditions to enterprise attributes, resulting in high maintenance costs and difficulty in adapting to frequent updates and diverse expressions in policy texts. Methods employing shallow machine learning models such as support vector machines typically transform policy texts and enterprise descriptions into bag-of-words models or TF-IDF feature vectors, performing matching through metrics such as cosine similarity. The main drawback of these methods is that they can only capture explicit keyword co-occurrence information in the text, failing to capture deep semantics, contextual relationships, and other nuances. Complex logical constraints are difficult to comprehend. For example, the policy clause "subsidies will be provided for production lines that adopt specific energy-saving technologies" not only involves the entity of "energy-saving technology" but also implies the application scenario of "production line" and the behavioral state of "adoption". Traditional methods are unable to effectively analyze such implicit composite conditions, let alone accurately correlate and reason with unstructured information such as the company's equipment list and technical transformation records. Therefore, existing technical solutions generally suffer from insufficient policy matching accuracy and low personalization, which may lead to companies receiving a large number of irrelevant policy pushes or policies that they do not meet the application requirements. This not only reduces the efficiency of the application process but also causes a mismatch between administrative resources and policy support opportunities. Summary of the Invention

[0004] This invention addresses the technical problems existing in the prior art by providing a policy intelligent matching system based on knowledge graphs. The system utilizes a knowledge encoding module, an association reasoning module, an intelligent matching module, and a federated optimization module to solve the problems mentioned in the background.

[0005] The technical solution of this invention to solve the above-mentioned technical problems is as follows: it specifically includes a knowledge encoding module, an association reasoning module, an intelligent matching module, and a federated optimization module connected in sequence; The knowledge encoding module is used to, upon receiving input data consisting of a knowledge graph, policy text, and enterprise description text, call the first knowledge graph embedding model to process the structured triples in the knowledge graph, generate structure embedding vectors, and simultaneously call the first pre-trained language model to process the policy text and enterprise description text respectively, generating semantic embedding vectors; then, the structure embedding vectors and semantic embedding vectors are adaptively weighted and fused to output a unified semantic representation vector corresponding to each entity node in the knowledge graph. The association reasoning module is used to input the unified semantic representation vector output by the knowledge encoding module as the initial node feature into the graph neural network model after obtaining the unified semantic representation vector. The graph neural network model updates the feature representation of each entity node through multiple rounds of message passing and neighbor information aggregation operations, so that the feature representation output by each node integrates the contextual information in its multi-hop neighborhood, and finally outputs the contextualized enhancement vector corresponding to each entity node in the knowledge graph. The intelligent matching module, upon receiving the contextualized enhanced vectors of policy entity nodes and enterprise entity nodes from the association reasoning module, first calculates the interaction weights between the features of both parties through a cross-attention mechanism, and generates mutually attention-enhanced policy feature vectors and enterprise feature vectors based on this. Then, it concatenates the mutually attention-enhanced policy feature vectors and enterprise feature vectors and inputs them into the first multilayer perceptron model. The first multilayer perceptron model calculates the refined matching score between policy and enterprise, and simultaneously locates and outputs key matching evidence based on the interaction weights. The federated optimization module is used to coordinate multiple clients to perform federated learning after the initial global model, consisting of the first knowledge graph embedding model and the first pre-trained language model in the knowledge encoding module (each containing its own trainable parameters), the graph neural network model in the associative reasoning module, and the first multilayer perceptron model in the intelligent matching module, is deployed. Each client trains the global model locally using its private data and calculates the update amount of the global model's trainable parameters. During training, a consistency constraint is introduced to address the difference between the trainable parameters of the local global model and the trainable parameters of the received global model. The central server aggregates the update amounts of the trainable parameters of the global models from all clients, generates and distributes new trainable parameters of the global model to update all trainable parameters corresponding to the first knowledge graph embedding model, the first pre-trained language model, the graph neural network model, and the first multilayer perceptron model. In a preferred embodiment, the knowledge encoding module calls a first knowledge graph embedding model to process structured triples in the knowledge graph, generating structured embedding vectors, and simultaneously calls a first pre-trained language model to process policy text and enterprise description text respectively, generating semantic embedding vectors. The specific execution process is as follows: When the knowledge encoding module receives the input data, it starts the first and second processing channels in parallel. In the first processing channel, the first knowledge graph embedding model models each structured triple consisting of a head entity, a relation, and a tail entity in the knowledge graph. By mapping the head entity, tail entity, and relation to a vector space, the corresponding head entity vector, tail entity vector, and relation vector are obtained. Using a trainable projection matrix corresponding to the relation, the head entity vector and tail entity vector are mapped to the corresponding semantic plane defined by the relation, respectively, to obtain the projected head entity vector and the projected tail entity vector. By optimizing a scoring function that aims to minimize the distance between the sum of the projected head entity vector and the relation vector and the projected tail entity vector, a structured embedding vector is finally calculated for each entity in the knowledge graph. In the second processing channel, the first pre-trained language model reads the policy text or enterprise description text associated with each entity, extracts the deep contextual semantic features of the text through its internal deep Transformer encoder, and generates a semantic embedding vector for each entity. The first processing channel and the second processing channel are executed synchronously, and respectively output the structural embedding vector and the semantic embedding vector corresponding to the same entity.

[0006] In a preferred embodiment, the specific operation of adaptively weighting and fusing the structural embedding vector and the semantic embedding vector is as follows: First, a trainable alignment transformation matrix is ​​introduced. This alignment transformation matrix is ​​used to perform a linear transformation on the semantic embedding vector generated by the second processing channel to project the semantic embedding vector from its original semantic subspace to a new semantic subspace that is compatible with the structural embedding vector, thereby obtaining an aligned semantic vector. Secondly, a trainable dynamic weight scalar parameter is introduced to dynamically adjust the contribution ratio of the information represented by the structural embedding vector and the information represented by the semantic embedding vector in the final representation. Finally, the unified semantic representation vector is generated by the following calculation: first, a hyperbolic tangent nonlinear activation function is applied to the aligned semantic vector to transform it, resulting in a transformed semantic vector; then, the structure embedding vector and the transformed semantic vector are weighted and summed according to the contribution ratio determined by the dynamic weight scalar parameter, thereby outputting a final unified semantic representation vector with fixed dimensions that integrates dual information.

[0007] In a preferred embodiment, the specific execution process of the graph neural network model in the association reasoning module, through multi-round message passing and neighbor information aggregation operations, is as follows: In each round of message passing, the graph neural network model processes each entity node in the knowledge graph. For each entity node that is the current processing target, its input feature is the feature vector from the previous iteration. For the first iteration, this input feature is the unified semantic representation vector output by the knowledge encoding module. First, based on the current feature vector of the target entity node itself and the current feature vectors of each of its first-order neighbor entity nodes, an attention coefficient representing the importance of the neighbor entity node to the current target entity node is calculated. The specific calculation process is as follows: The current feature vector of the target entity node and the current feature vectors of its first-order neighbor entity nodes are each multiplied by a trainable parameter weight matrix defined in this round of message passing to perform a linear transformation. The feature representation of the target entity node obtained after the linear transformation is concatenated with the feature representation of the neighbor entity node to form a combined feature vector. The combined feature vector is then multiplied by a trainable attention vector defined in this round of message passing. Finally, a leaky linear rectified unit activation function is applied to the result of the dot product to introduce nonlinearity and output the attention coefficients. Subsequently, the attention coefficients corresponding to all neighbor entity nodes are normalized using the Softmax function to obtain the normalized attention weights corresponding to each neighbor entity node. Finally, the feature vectors of each neighbor entity node after the linear transformation by the trainable parameter weight matrix are weighted and summed according to their corresponding normalized attention weights to obtain the neighbor message vector aggregated by the target entity node in this round.

[0008] In a preferred embodiment, the specific process of outputting the contextualized enhancement vector corresponding to each node in the knowledge graph is as follows: After obtaining the aggregated neighbor message vectors, the feature of the entity node currently being processed is updated. Specifically, the feature update process involves multiplying the feature vector of the current entity node by a first trainable parameter weight matrix defined in the current message passing round to obtain a first linear transformation result. Simultaneously, the aggregated neighbor message vectors are multiplied by a second trainable parameter weight matrix defined in the same message passing round to obtain a second linear transformation result. The first and second linear transformation results are added together, and a non-linear activation function is applied to the sum to generate a new feature vector for the current entity node. This new feature vector will serve as the input feature vector for the next round of message passing and aggregation operations. The message passing, neighbor aggregation, and node feature update process is repeated as a single iterative step, executed a predetermined number of times. The final new feature vectors for each entity node obtained after the last iteration constitute a final feature vector set, where each vector is defined as a contextualized enhancement vector.

[0009] In a preferred embodiment, the intelligent matching module calculates the interaction weights between the features of both parties through a cross-attention mechanism, and generates policy feature vectors and enterprise feature vectors enhanced with mutual attention based on this. The specific process is as follows: First, linear transformations are performed on one contextualized augmentation vector representing a policy entity node and another representing a corporate entity node from the final feature vector set output by the associative reasoning module, generating their respective query vector sets, key vector sets, and value vector sets. Next, based on a multi-attention head mechanism, in each attention head, the query vector set from the policy entity node and the key vector set from the corporate entity node interact. Using a trainable bilinear transformation matrix defined in that attention head, the bilinear interaction score between the policy entity node query vector and the corporate entity node key vector is calculated, serving as the initial attention weight for focusing on enterprises from a policy perspective. The initial attention weight for focusing on policies from a corporate perspective is also symmetrically calculated. Then, the initial attention weights for focusing on enterprises from a policy perspective and for focusing on policies from a corporate perspective are normalized using a row-wise Softmax function, forming standardized policy-to-enterprise attention weight matrices and enterprise-to-policy attention weight matrices. Finally, the policy-to-enterprise attention weight matrix is ​​used... The value vectors of enterprise entity nodes are weighted and summed to obtain the enterprise context information fused with policy entity nodes, and the policy context information fused with enterprise entity nodes is obtained symmetrically. Finally, for each attention head in the multi-attention head mechanism, a corresponding learnable gating scalar is introduced, and the importance of the enterprise context information generated by its corresponding attention head is weighted using each learnable gating scalar. The enterprise context information corresponding to all attention heads after weighting by the learnable gating scalars is concatenated to form an aggregated context vector. The aggregated context vector is multiplied by a trainable output projection matrix to obtain the projected aggregated context. The projected aggregated context is added to the original policy entity node contextual enhancement vector to achieve a residual connection. Layer normalization is applied to the vector obtained after the residual connection to output the final mutual attention-enhanced policy feature vector. The same symmetrical steps are used to process the policy context information fused with enterprise entity nodes and the original enterprise entity node contextual enhancement vector to generate the mutual attention-enhanced enterprise feature vector.

[0010] In a preferred embodiment, the specific process of concatenating the mutual attention-enhanced policy feature vector and the mutual attention-enhanced enterprise feature vector and inputting them into the first multilayer perceptron model to calculate the refined matching score is as follows: First, the element-wise product between the policy feature vector enhanced by mutual attention and the enterprise feature vector enhanced by mutual attention is calculated to obtain an element-wise product vector. Simultaneously, the absolute values ​​of the corresponding element-wise differences between the policy feature vector enhanced by mutual attention and the enterprise feature vector enhanced by mutual attention are calculated to obtain an absolute difference vector. Then, the policy feature vector enhanced by mutual attention, the enterprise feature vector enhanced by mutual attention, the element-wise product vector, and the absolute difference vector are concatenated along the feature dimension to form a high-order interaction feature vector. Next, the high-order interaction feature vector is input into the first multilayer perceptron model, which consists of multiple fully connected layers stacked sequentially. The intermediate layers use nonlinear activation functions to perform layer-by-layer nonlinear transformation and feature abstraction on the high-order interaction feature vector through the multiple fully connected layers. Finally, the last fully connected output layer of the first multilayer perceptron model maps the deeply abstracted features into a scalar value, which is the refined matching score between the policy and the enterprise.

[0011] In a preferred embodiment, the specific process of locating and outputting key matching evidence based on interaction weights is as follows: First, the policy-to-enterprise attention weight matrices and enterprise-to-policy attention weight matrices corresponding to each attention head generated during the calculation of interaction weights are aggregated to generate a comprehensive policy-enterprise interaction attention graph. Next, in the comprehensive policy-enterprise interaction attention graph, key interaction locations representing strong associations are selected based on a preset weight threshold. Then, the selected key interaction locations are mapped back to entities and attributes in the original knowledge graph. Specifically, the policy-side feature dimensions corresponding to the key interaction locations are associated with entities and attributes in the knowledge graph describing specific policy clauses or conditions; the enterprise-side features corresponding to the key interaction locations are... The system identifies dimensions and associates them with entities and attributes in the knowledge graph that describe enterprise qualifications or operating indicators. Based on these associations, it generates natural language evidence fragments describing the relationship between these key policy provisions and enterprise qualifications. Simultaneously, based on the policy entity node set and enterprise entity node set associated with the key interaction locations, it extracts a minimum connected subgraph in the knowledge graph that connects all relevant nodes in the policy entity node set and the enterprise entity node set. This minimum connected subgraph visually displays the core knowledge association path supporting this matching decision. Finally, it integrates the natural language evidence fragments with the minimum connected subgraph to output a structured key matching evidence report.

[0012] In a preferred embodiment, in the federated optimization module, each client locally trains the global model using private data and calculates the update amount of the trainable parameters of the global model. During training, a consistency constraint is introduced to address the difference between the trainable parameters of the local global model and the trainable parameters of the received global model. The specific process is as follows: In each round of training in federated learning, each client receives the current global model parameters from the central server. The client then trains its model locally using its private dataset, initialized with these received global model parameters. The number of samples in the private dataset constitutes the client's local data volume. During training, the client constructs a loss function consisting of two parts: the first part is the task loss; the second part is the consistency comparison loss. The construction and calculation process of the consistency comparison loss is as follows: After obtaining the feature representation of the sample through forward propagation of the model, a trainable lightweight projector is used to map this feature representation to a subspace dedicated to contrastive learning. Two different random data augmentation operations are applied to the same batch of training data samples to obtain two sets of augmented samples, and the corresponding two sets of projected feature representations are obtained through the projector. The projected feature representations from two different augmented views of the same sample are formed into a positive sample pair, and the pairing of projected feature representations from different samples is formed into a negative sample pair. The similarity between the features of the positive sample pairs is calculated. At the same time, the similarity between the feature representation generated by the currently trained local model for the original un-augmented sample and the feature representation generated by the frozen global model corresponding to the received current global model parameters for the same original sample is calculated, and this similarity is incorporated into the loss calculation as a consistency regularization term. The task loss and the consistency contrastive loss are weighted and summed according to a preset balance coefficient to form the client's total local training loss. The client minimizes this total local training loss through an optimization algorithm, calculates the updated local model parameters, and then calculates the update amount of the local model parameters relative to the received current global model parameters.

[0013] In a preferred embodiment, the central server aggregates the update amounts of the trainable parameters of the global model from all clients, generates and distributes new trainable parameters of the global model, and the specific process is as follows: The central server receives model parameter updates reported by each client, as well as local training quality evaluation metrics calculated by each client based on its local training results for this round. These local training quality evaluation metrics include the performance improvement of the client's model on the local validation set after this round of local training, and the stability metric of the local training process. The central server calculates a dynamic adaptive aggregation weight for each client based on its local data volume, the performance improvement, and the stability metric. The calculation process for the adaptive aggregation weight is as follows: First, the performance improvement of each client is numerically normalized using the Sigmoid function; simultaneously, the stability metric of each client is numerically mapped using the hyperbolic tangent function; next, the local data volume, the performance improvement processed by the Sigmoid function, and the stability metric processed by the hyperbolic tangent function are multiplied to obtain an intermediate weight factor for calculating the client's weight; then, the intermediate weight factors of all clients are summed to obtain a total; finally, the intermediate weight factor of each client is divided by the total to obtain the adaptive aggregation weight corresponding to that client. The central server processes the model parameter updates reported by each client. The parameters are weighted and summed according to their corresponding adaptive aggregation weights to obtain the parameter update amount of the global model. Then, the central server adds the currently held global model parameters to the weighted summation of the global model parameter update amount, according to a preset global learning rate, to generate a new round of global model parameters. The central server does not distribute all the new round of global model parameters to all clients, but instead employs a selective synchronization strategy: it analyzes the overall model composed of the knowledge encoding module, the association reasoning module, and the intelligent matching module in this round of aggregation, specifically the first knowledge graph embedding model and the first pre-trained model. The training process involves analyzing the changes in trainable parameters of the four models—the language model, the graph neural network model, and the first multilayer perceptron model—relative to the changes in the global model parameters from the previous round. For stable parameters whose changes are below a preset threshold, the central server chooses not to distribute updates to these stable parameters in the next round of federated learning. Instead, it instructs each client to continue using the local parameter copies corresponding to these stable parameters that they held after the previous round of training. Only active parameters whose changes are greater than or equal to the preset threshold are distributed to each client along with the basic parameters necessary to maintain model functionality, thus completing the model update.

[0014] The beneficial effects of this invention are as follows: By deeply integrating multi-source heterogeneous data with the topological association of knowledge graphs, it achieves deep semantic understanding and accurate matching between policy provisions and enterprise profiles. The generated matching results are not only highly accurate and personalized, but also provide traceable key evidence, significantly improving the reliability of policy recommendations and the efficiency of application. At the same time, with the help of the federated learning framework, it can continuously absorb data experience scattered in various places under the premise of strictly protecting data privacy, so that the model can continuously evolve and adapt to diverse regional and industry scenarios, thereby improving the sense of gain for enterprises and helping to achieve better allocation of policy resources. Attached Figure Description

[0015] Figure 1 This is a flowchart of the method of the present invention; Figure 2 This is a block diagram of the system structure of the present invention. Detailed Implementation

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

[0017] In the description of this application, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of the stated features. In the description of this application, "multiple" means two or more, unless otherwise explicitly specified.

[0018] In the description of this application, the term "for example" is used to mean "used as an example, illustration, or description." Any embodiment described as "for example" in this application is not necessarily to be construed as being more preferred or advantageous than other embodiments. The following description is provided to enable any person skilled in the art to make and use the invention. Details are set forth in the following description for purposes of explanation. It should be understood that those skilled in the art will recognize that the invention can be made without using these specific details. In other instances, well-known structures and processes will not be described in detail to avoid obscuring the description of the invention with unnecessary detail. Therefore, the invention is not intended to be limited to the embodiments shown, but is consistent with the broadest scope of the principles and features disclosed in this application.

[0019] Example 1 This embodiment provides, for example Figure 1-2The system illustrates a policy intelligent matching system based on a knowledge graph, which specifically includes: a knowledge encoding module, an association reasoning module, an intelligent matching module, and a federated optimization module connected in sequence. The knowledge encoding module is used to, upon receiving input data consisting of a knowledge graph, policy text, and enterprise description text, call the first knowledge graph embedding model to process the structured triples in the knowledge graph, generate structure embedding vectors, and simultaneously call the first pre-trained language model to process the policy text and enterprise description text respectively, generating semantic embedding vectors; then, the structure embedding vectors and semantic embedding vectors are adaptively weighted and fused to output a unified semantic representation vector corresponding to each entity node in the knowledge graph. The association reasoning module is used to input the unified semantic representation vector output by the knowledge encoding module as the initial node feature into the graph neural network model after obtaining the unified semantic representation vector. The graph neural network model updates the feature representation of each entity node through multiple rounds of message passing and neighbor information aggregation operations, so that the feature representation output by each node integrates the contextual information in its multi-hop neighborhood, and finally outputs the contextualized enhancement vector corresponding to each entity node in the knowledge graph. The intelligent matching module, upon receiving the contextualized enhanced vectors of policy entity nodes and enterprise entity nodes from the association reasoning module, first calculates the interaction weights between the features of both parties through a cross-attention mechanism, and generates mutually attention-enhanced policy feature vectors and enterprise feature vectors based on this. Then, it concatenates the mutually attention-enhanced policy feature vectors and enterprise feature vectors and inputs them into the first multilayer perceptron model. The first multilayer perceptron model calculates the refined matching score between policy and enterprise, and simultaneously locates and outputs key matching evidence based on the interaction weights. The federated optimization module is used to coordinate multiple clients to perform federated learning after the initial global model, consisting of the first knowledge graph embedding model and the first pre-trained language model in the knowledge encoding module (which contain their respective trainable parameters), the graph neural network model in the association reasoning module, and the first multilayer perceptron model in the intelligent matching module, is deployed. Each client trains the global model locally using its private data and calculates the update amount of the global model's trainable parameters. During the training process, consistency constraints are introduced to address the differences between the trainable parameters of the local global model and the trainable parameters of the received global model. The central server aggregates the update amounts of the trainable parameters of the global models from all clients, generates and distributes new trainable parameters of the global model, and updates all trainable parameters corresponding to the first knowledge graph embedding model, the first pre-trained language model, the graph neural network model, and the first multilayer perceptron model.

[0020] In this embodiment, it is specifically necessary to explain that in the knowledge encoding module, the first knowledge graph embedding model is called to process the structured triples in the knowledge graph to generate structured embedding vectors, and the first pre-trained language model is called simultaneously to process the policy text and enterprise description text respectively to generate semantic embedding vectors. The specific execution process is as follows: Once the knowledge encoding module receives the input data, it starts the first and second processing channels in parallel. In the first processing channel, the first knowledge graph embedding model models each structured triple consisting of a head entity, a relation, and a tail entity in the knowledge graph. It maps the head entity, tail entity, and relation to a vector space to obtain corresponding head entity vectors, tail entity vectors, and relation vectors, respectively. Using a trainable projection matrix corresponding to the relation, it maps the head entity vector and tail entity vector to the corresponding semantic plane defined by the relation, resulting in projected head entity vectors and projected tail entity vectors. By optimizing a scoring function that minimizes the distance between the sum of the projected head entity vector and relation vector and the projected tail entity vector, a structured embedding vector representing the network topology and relation information is finally calculated for each entity in the knowledge graph. The scoring function can be constructed based on L1 or L2 norm distance. During model training, it is optimized by minimizing the distance scores of all positive triples and maximizing the distance scores of negative triples, making entity pairs satisfying the relation closer in the corresponding relation semantic plane in the vector space. In the second processing channel, the first pre-trained language model reads the policy text or enterprise description text associated with each entity, extracts the deep contextual semantic features of the text through its internal deep Transformer encoder, and generates a semantic embedding vector for each entity that represents its rich linguistic semantics. The semantic embedding vector is typically a vector representation of the [CLS] tag corresponding to the input sequence encoded by the Transformer encoder. This vector aggregates the global semantic information of the entire input text. The first processing channel and the second processing channel are executed synchronously, respectively outputting the structural embedding vector and the semantic embedding vector corresponding to the same entity; The specific operation for adaptively weighted fusion of structural embedding vectors and semantic embedding vectors is as follows: First, a trainable alignment transformation matrix is ​​introduced, where the number of rows equals the dimension of the structural embedding vector and the number of columns equals the dimension of the semantic embedding vector. This alignment transformation matrix is ​​used to linearly transform the semantic embedding vector generated by the second processing channel, projecting the semantic embedding vector from its original semantic subspace to a new semantic subspace that fits the structural embedding vector, thus obtaining an aligned semantic vector. The alignment transformation matrix is ​​learned along with other parameters during model training, with the aim of mapping the semantic information from the text to a common vector subspace that can effectively interact and fuse with the structural information from the knowledge graph. Secondly, a trainable dynamic weight scalar parameter is introduced. This dynamic weight scalar parameter takes a value between zero and one. Its specific value is determined during model training based on the type and context of the entity being processed, and is adjusted together with the alignment transformation matrix through an optimization algorithm. It is used to dynamically adjust the contribution ratio of the information represented by the structural embedding vector and the information represented by the semantic embedding vector in the final representation. For example, for entities with rich connections in the knowledge graph but brief text descriptions, the dynamic weight scalar parameter tends to be assigned a larger value after training, making the final representation more dependent on the structural embedding vector. Conversely, for entities with detailed text descriptions but sparse graph connections, this parameter tends to be assigned a smaller value, making the final representation more dependent on the aligned and transformed semantic information. Finally, a unified semantic representation vector is generated through the following calculation: First, a hyperbolic tangent nonlinear activation function is applied to the aligned semantic vector to transform it, resulting in a transformed semantic vector. The hyperbolic tangent activation function is used to nonlinearly scale each dimension of the aligned semantic vector, constraining its numerical range to between -1 and +1, thereby enhancing the model's nonlinear expressive power and promoting training stability. Subsequently, the structure embedding vector and the transformed semantic vector are weighted and summed according to the contribution ratio determined by the dynamic weight scalar parameters, thus outputting a final unified semantic representation vector with fixed dimensions that integrates dual information. This unified semantic representation vector, as the output of the knowledge encoding module, will be directly called as the initial node feature of the downstream association reasoning module. This fusion mechanism ensures that for each entity, its final unified semantic representation vector is an adaptive hybrid combining its structured association and textual description, laying a more accurate and robust feature foundation for subsequent deep semantic understanding and matching.

[0021] In this embodiment, it is specifically necessary to explain the execution process of the graph neural network model in the association reasoning module, which involves multi-round message passing and neighbor information aggregation: In each round of message passing, the graph neural network model processes each entity node in the knowledge graph. For each entity node that is the current processing target, its input feature is the feature vector from the previous iteration. For the first iteration, this input feature is the unified semantic representation vector output by the knowledge encoding module. First, based on the current feature vector of the target entity node itself and the current feature vectors of each of its first-order neighbor entity nodes, an attention coefficient representing the importance of the neighbor entity node to the current target entity node is calculated. The specific calculation process is as follows: The current feature vector of the target entity node and the current feature vector of its first-order neighbor entity nodes are each multiplied by a trainable parameter weight matrix defined in this round of message passing to perform a linear transformation. The feature representation of the target entity node obtained after the linear transformation is concatenated with the feature representation of its neighbor entity node to form a combined feature vector. The combined feature vector is then multiplied by a trainable attention vector defined in this round of message passing. Finally, a leaky linear rectified unit activation function is applied to the result of the dot product to introduce nonlinearity and output attention coefficients. The leaky linear rectified unit activation function allows a small, non-zero gradient to pass through when the input is negative, which helps to alleviate the neuron "death" problem that may occur during training, thereby improving the stability and expressive power of model training. Subsequently, So... The ftmax function normalizes the attention coefficients of all neighboring entity nodes, obtaining a normalized attention weight for each neighboring entity node. The Softmax function transforms each attention coefficient into a probability value between 0 and 1, and the sum of the probability values ​​of all neighbors is 1, thus giving the weighted summation operation a clear probabilistic interpretation and highlighting the most important neighbor information. Finally, the feature vector of each neighboring entity node, after being linearly transformed by the trainable parameter weight matrix, is weighted and summed according to its corresponding normalized attention weight to obtain the neighbor message vector of the current target entity node in this round of aggregation. This weighted summation operation achieves differentiated information aggregation; neighboring nodes with stronger semantic relevance to the current target entity node have larger normalized attention weights, thus contributing more to the neighbor message vector. The specific process of outputting the contextualized enhancement vector corresponding to each node in the knowledge graph is as follows: After obtaining the aggregated neighbor message vectors, the features of the entity node currently being processed are updated. Specifically, this update process involves multiplying the feature vector of the current entity node by a first trainable parameter weight matrix defined in the current message passing round, resulting in a first linear transformation. Simultaneously, the aggregated neighbor message vectors are multiplied by a second trainable parameter weight matrix defined in the same message passing round, resulting in a second linear transformation. The first and second linear transformation results are then added together, and a non-linear activation function is applied to the sum to generate a new feature vector for the current entity node. This update formula explicitly models the preservation of the node's own features and the fusion of neighbor information. The first trainable parameter weight matrix controls the transmission and transformation intensity of the node's own historical information, while the second trainable parameter weight matrix controls the fusion intensity of the aggregated neighbor context information. The optimal balance between the two is achieved through adaptive learning during training. The new feature vector will serve as the input feature vector for the next round of message passing and aggregation operations. The process of message passing, neighbor aggregation, and node feature updating... The process, as a whole iterative step, is repeatedly executed a pre-set total number of layers. The total number of layers, L, is an important hyperparameter, whose value determines the range of information propagation in the knowledge graph network. If the value of L is too small, it may lead to insufficient acquisition of contextual information from a distance; if the value of L is too large, it may introduce too much noise or lead to excessive smoothing. Typically, the value of L ranges from 2 to 4, and needs to be determined experimentally based on the diameter and density of the specific knowledge graph. After the last iteration, the final new feature vector corresponding to each entity node constitutes a final feature vector set. Each vector in this set is defined as a contextualized augmentation vector. Compared with the unified semantic representation vector used as input, the contextualized augmentation vector not only encodes the semantics of the corresponding entity itself, but also encodes the local structural context and global relational patterns of the entity in the knowledge graph network at a deeper level. For example, the contextualized augmentation vector of a node describing the "R&D expense deduction" policy will contain the association patterns between it and qualification nodes such as "high-tech enterprises" and "technology-based SMEs," as well as industry nodes such as "manufacturing" and "software industry," so that its applicable scenarios can be understood more comprehensively during matching.

[0022] In this embodiment, it is specifically necessary to explain that in the intelligent matching module, the interaction weight between the features of both parties is calculated through a cross-attention mechanism, and based on this, the policy feature vector and enterprise feature vector enhanced by mutual attention are generated. The specific process is as follows: First, linear transformations are performed on one contextualized augmentation vector representing a policy entity node and another representing a business entity node from the final feature vector set output by the associative reasoning module, generating their respective query vector sets, key vector sets, and value vector sets. The linear transformation is achieved by multiplying by different trainable weight matrices, aiming to project the input vectors onto a subspace suitable for computing attention interactions. Next, based on a multi-attention head mechanism, in each attention head, the query vector set from the policy entity node and the key vector set from the business entity node interact. Using a trainable bilinear transformation matrix defined in that attention head, the interaction between the policy entity node query vector and the business entity node key vector is calculated. The bilinear interaction score between the policy and enterprise nodes is used as the initial attention weight for focusing on enterprises from a policy perspective, and the initial attention weight for focusing on policy from an enterprise perspective is calculated symmetrically. The trainable bilinear transformation matrix enhances the model's ability to capture complex, nonlinear interactions between queries and keys, and can model the correlation strength between features more precisely than a simple dot product operation. Then, the initial attention weights for focusing on enterprises from a policy perspective and the initial attention weights for focusing on policy from an enterprise perspective are normalized using a row-wise Softmax function, forming standardized policy-to-enterprise attention weight matrices and enterprise-to-policy attention weight matrices. This normalization ensures that the attention weights of each entity node on all its neighbor nodes are equal. The summation process, by unifying the values, provides a clear probabilistic interpretation for the weighted summation operation and allows for adaptive focusing on the most important related components. Subsequently, the policy-to-enterprise attention weight matrix is ​​used to perform a weighted summation of the value vectors of enterprise entity nodes, yielding the enterprise context information fused with policy entity nodes, and symmetrically obtaining the policy context information fused with enterprise entity nodes. Finally, for each attention head in the multi-attention head mechanism, a corresponding learnable gating scalar is introduced. Each learnable gating scalar is used to weight the importance of the enterprise context information generated by its corresponding attention head. The learnable gating scalar is optimized along with other parameters during model training, enabling the model to automatically learn and emphasize information from different semantic subspaces. The key context information is extracted while suppressing potential noise or redundant information; the enterprise context information corresponding to all attention heads after being weighted by each learnable gating scalar is concatenated to form an aggregated context vector; the aggregated context vector is multiplied by a trainable output projection matrix to obtain the projected aggregated context; the projected aggregated context is added to the original policy entity node contextual enhancement vector to achieve residual connection; residual connection helps to alleviate the gradient vanishing problem in deep networks and ensures that the core semantic features of the original input are preserved while fusing rich context information; layer normalization is applied to the vector obtained after residual connection to output the final cross-attention enhanced policy feature vector;Using the same symmetrical steps, the policy context information of enterprise entity node fusion and the original contextualized enhancement vector of enterprise entity node are processed to generate enterprise feature vectors with mutual attention enhancement. The policy feature vector enhanced by mutual attention and the enterprise feature vector enhanced by mutual attention are concatenated and input into the first multilayer perceptron model to calculate the refined matching score. The specific process is as follows: First, the element-wise product between the mutual attention-enhanced policy feature vector and the mutual attention-enhanced firm feature vector is calculated to obtain an element-wise product vector. This element-wise product is used to explicitly capture the synergistic effect and co-occurrence pattern of the two feature vectors across various dimensions. Simultaneously, the absolute values ​​of the corresponding element-wise differences between the mutual attention-enhanced policy feature vector and the mutual attention-enhanced firm feature vector are calculated to obtain an absolute difference vector. The absolute difference is used to characterize the degree of difference and distance information between the two feature vectors across various dimensions. Then, the mutual attention-enhanced policy feature vector, the mutual attention-enhanced firm feature vector, the element-wise product vector, and the absolute difference vector are concatenated along the feature dimensions to form a higher-order interactive feature vector. This concatenation method forces the first multilayer perceptron model to consider features simultaneously. The study of features themselves, their synergistic relationships, and the differences between them provides a more comprehensive and representative foundation for matching degree calculation. Then, the high-order interactive feature vectors are input into the first multilayer perceptron model, which consists of multiple fully connected layers stacked sequentially. The intermediate layers use nonlinear activation functions to perform layer-by-layer nonlinear transformations and feature abstraction on the high-order interactive feature vectors. Nonlinear activation functions, such as the ReLU function, introduce nonlinear fitting capabilities to the model, enabling it to learn and simulate the complex, nonlinear matching relationships between policy features and enterprise features. Finally, the last fully connected output layer of the first multilayer perceptron model maps the deeply abstracted features into a scalar value, which is the refined matching score between policy and enterprise. The specific process of locating and outputting key matching evidence based on interaction weights is as follows: First, the policy-to-enterprise attention weight matrices and enterprise-to-policy attention weight matrices corresponding to each attention head generated during the calculation of interaction weights are aggregated to generate a comprehensive policy-enterprise interaction attention graph. Aggregation typically involves averaging the weight matrices corresponding to each attention head along the attention head dimension to integrate multi-perspective interaction information and form a stable, global view of relationships. Next, in the comprehensive policy-enterprise interaction attention graph, key interaction locations representing strong relationships are selected based on a preset weight threshold. The preset weight threshold is determined by calculating the statistical quantiles of all attention weight values; specifically, the threshold is set to the value in the top tenths after all attention weight values ​​are sorted from largest to smallest, thus identifying key interactions with significantly higher than average relationship levels. Then, the selected key interaction locations are mapped back to entities and attributes in the original knowledge graph. Specifically, the policy-side feature dimensions corresponding to the key interaction locations are associated with the entities and attributes described in the knowledge graph. The system identifies the entities and attributes of specific policy clauses or conditions; it associates the enterprise-side feature dimensions corresponding to key interaction locations with the entities and attributes describing enterprise qualifications or operating indicators in the knowledge graph; based on the above association, it generates natural language evidence fragments describing the relationship between these key policy clauses and enterprise qualifications, such as generating a text description that "the 'R&D investment ratio' condition in the policy is highly correlated with the enterprise's 'R&D expense' indicator"; simultaneously, based on the policy entity node set and enterprise entity node set associated with the key interaction locations, it extracts a minimum connected subgraph in the knowledge graph that connects all relevant nodes in the policy entity node set and the enterprise entity node set. This minimum connected subgraph intuitively displays the core knowledge association path supporting this matching decision; the minimum connected subgraph is obtained through a graph traversal algorithm, which reveals the semantic bridge and logical chain between policy clauses and enterprise qualifications in the simplest path form; finally, it integrates the natural language evidence fragments and the minimum connected subgraph to output a structured key matching evidence report.

[0023] In this embodiment, it is specifically necessary to explain that in the federated optimization module, each client uses private data locally to train the global model and calculates the update amount of the trainable parameters of the global model. During the training process, a consistency constraint is introduced to address the difference between the trainable parameters of the local global model and the trainable parameters of the received global model. The specific process is as follows: In each round of training in federated learning, each client receives the current global model parameters from the central server. The client then trains its model locally using its private dataset, initialized with these received global model parameters. The number of samples in the private dataset constitutes the client's local data volume. During training, the client constructs a loss function consisting of two parts: the first part is the task loss, which aims to minimize the matching prediction error between policy and enterprise sample pairs in the client's local data; the second part is the consistency contrast loss, which aims to constrain the representation space of the local model to remain aligned with the representation space of the received global model at the feature representation level, while improving the robustness of the local model to small perturbations in the input data. The consistency contrast loss forces the model to produce similar representations for different augmented views of the same sample and dissimilar representations for different samples, thus learning more robust and discriminative features. Simultaneously, by constraining the consistency between the local model and the frozen global model in representing the original samples, it prevents local training from deviating excessively from global consensus, effectively mitigating the client drift problem in federated learning. The specific construction and calculation process of the consistency contrast loss is as follows: After obtaining the feature representations of the samples through forward propagation of the model, a trainable lightweight projector is used to map these feature representations to a subspace dedicated to contrastive learning. Two different random data augmentation operations are applied to the same batch of training data samples to obtain two sets of augmented samples, and the corresponding two sets of projected feature representations are obtained through the projector. The two different random data augmentation operations may include, but are not limited to, random masking of the input text, word order shuffling, or random noise injection into numerical features, aiming to construct semantically consistent but superficially different views from the same data. The projected feature representations of two different augmented views from the same sample are combined to form a positive sample pair, and the pairings between projected feature representations from different samples are combined to form a negative sample pair. The similarity between the features of the positive sample pair is calculated and set higher than that of the features of the negative sample pair. The similarity between features is calculated. Simultaneously, the similarity between the feature representations generated by the currently trained local model for the original unenhanced samples and the feature representations generated by the frozen global model corresponding to the received current global model parameters for the same original samples is calculated. This similarity is incorporated into the loss calculation as a consistency regularization term. This similarity is typically calculated in the form of cosine similarity or the negative of L2 distance, and serves as a regularization term to encourage alignment between local and global features in the vector space. The task loss and consistency comparison loss are weighted and summed according to a preset balance coefficient to constitute the client's total local training loss. The client minimizes this total local training loss using an optimization algorithm, calculates the updated local model parameters, and then calculates the update amount of the local model parameters relative to the received current global model parameters. The central server aggregates the updates to the trainable parameters of the global model from all clients, generates and distributes new trainable parameters for the global model. The specific process is as follows: The central server receives model parameter updates reported by each client, as well as local training quality evaluation metrics calculated by each client based on its local training results for this round. These metrics include the client's model performance improvement on the local validation set after this round of local training, and a measure of the stability of the local training process. The central server calculates a dynamic adaptive aggregation weight for each client based on its local data volume, performance improvement, and stability metrics. This adaptive aggregation strategy comprehensively considers data volume, training effectiveness, and training robustness, dynamically reducing update weights from clients with poor data quality or unstable training, thereby improving the quality and convergence stability of the global model aggregation. The adaptive aggregation weighting process is as follows: First, the performance improvement of each client is numerically normalized using the Sigmoid function; simultaneously, the stability metric of each client is numerically mapped using the hyperbolic tangent function, constraining it to a range of zero to one; next, the local data volume of each client, the performance improvement after Sigmoid function processing, and the stability metric after hyperbolic tangent function processing are multiplied to obtain an intermediate weighting factor used to calculate the client's weight; then, the intermediate weighting factors of all clients are summed to obtain a total; finally, the intermediate weighting factor of each client is divided by the total to obtain the adaptive aggregation weight corresponding to that client. This calculation method makes local data... Clients with larger scale, more significant performance improvements, and more stable training processes are given higher weights in the aggregation process. The central server calculates the model parameter updates reported by each client using their corresponding adaptive aggregation weights, resulting in the global model parameter updates. Then, the central server adds its current global model parameters to the weighted global model parameter updates using a preset global learning rate, generating a new set of global model parameters. Instead of distributing all new global model parameters to all clients, the central server employs a selective synchronization strategy: analyzing the overall model comprised of the knowledge encoding module, the association reasoning module, and the intelligent matching module in this aggregation round, i.e., the first... The four models—knowledge graph embedding model, first pre-trained language model, graph neural network model, and first multilayer perceptron model—are defined as follows: the magnitude of change of the trainable parameters of each component relative to the parameters of the previous global model. The magnitude of change can be measured by calculating the relative rate of change of the L2 norm or cosine similarity of the parameter vectors before and after iteration. For stable parameters whose magnitude of change is below a preset threshold, the central server chooses not to issue updates to these stable parameters in the next round of federated learning. Instead, it instructs each client to continue using the local parameter copies corresponding to these stable parameters held after the previous round of training in its local training. The preset threshold can be set empirically, for example, parameters with a relative rate of change of less than one percent or two percent are judged as stable parameters.Only active parameters with changes greater than or equal to a preset threshold are sent to each client along with the basic parameters necessary to maintain model functionality to complete model updates. This selective synchronization strategy significantly reduces the amount of communication data per round of federated learning, making it particularly suitable for scenarios with large model parameter sizes. It also allows stable parameters to undergo longer periods of personalized adaptation on the client side, helping to improve the model's personalized performance while ensuring global consistency.

[0024] It should be noted that the descriptions of each embodiment in the above embodiments have different focuses. For parts that are not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0025] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0026] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0027] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0028] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0029] Although preferred embodiments of the invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the invention.

[0030] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A policy intelligent matching system based on knowledge graphs, characterized in that, Specifically, it includes: The knowledge encoding module, the associative reasoning module, the intelligent matching module, and the federated optimization module are connected sequentially. The knowledge encoding module is used to, upon receiving input data consisting of a knowledge graph, policy text, and enterprise description text, call the first knowledge graph embedding model to process the structured triples in the knowledge graph, generate structure embedding vectors, and simultaneously call the first pre-trained language model to process the policy text and enterprise description text respectively, generating semantic embedding vectors; then, the structure embedding vectors and semantic embedding vectors are adaptively weighted and fused to output a unified semantic representation vector corresponding to each entity node in the knowledge graph. The association reasoning module is used to input the unified semantic representation vector output by the knowledge encoding module as the initial node feature into the graph neural network model after obtaining the unified semantic representation vector. The graph neural network model updates the feature representation of each entity node through multiple rounds of message passing and neighbor information aggregation operations, so that the feature representation output by each node integrates the contextual information in its multi-hop neighborhood, and finally outputs the contextualized enhancement vector corresponding to each entity node in the knowledge graph. The intelligent matching module, upon receiving the contextualized enhanced vectors of policy entity nodes and enterprise entity nodes from the association reasoning module, first calculates the interaction weights between the features of both parties through a cross-attention mechanism, and generates mutually attention-enhanced policy feature vectors and enterprise feature vectors based on this. Then, it concatenates the mutually attention-enhanced policy feature vectors and enterprise feature vectors and inputs them into the first multilayer perceptron model. The first multilayer perceptron model calculates the refined matching score between policy and enterprise, and simultaneously locates and outputs key matching evidence based on the interaction weights. The federated optimization module is used to coordinate multiple clients to perform federated learning after the initial global model, consisting of a first knowledge graph embedding model and a first pre-trained language model in the knowledge encoding module containing their respective trainable parameters, a graph neural network model in the associative reasoning module, and a first multilayer perceptron model in the intelligent matching module, is deployed. Each client trains the global model locally using private data and calculates the update amount of the trainable parameters of the global model. During the training process, consistency constraints are introduced to address the differences between the trainable parameters of the local global model and the trainable parameters of the received global model. The central server aggregates the update amounts of the trainable parameters of the global model from all clients, generates and distributes new trainable parameters of the global model, and updates all trainable parameters corresponding to the first knowledge graph embedding model, the first pre-trained language model, the graph neural network model and the first multilayer perceptron model.

2. The policy intelligent matching system based on knowledge graphs according to claim 1, characterized in that: In the knowledge encoding module, the first knowledge graph embedding model is invoked to process the structured triples in the knowledge graph, generating structured embedding vectors. Simultaneously, the first pre-trained language model is invoked to process the policy text and enterprise description text respectively, generating semantic embedding vectors. The specific execution process is as follows: When the knowledge encoding module receives the input data, it starts the first and second processing channels in parallel. In the first processing channel, the first knowledge graph embedding model models each structured triple consisting of a head entity, a relation, and a tail entity in the knowledge graph. By mapping the head entity, tail entity, and relation to a vector space, the corresponding head entity vector, tail entity vector, and relation vector are obtained. Using a trainable projection matrix corresponding to the relation, the head entity vector and tail entity vector are mapped to the corresponding semantic plane defined by the relation, respectively, to obtain the projected head entity vector and the projected tail entity vector. By optimizing a scoring function that aims to minimize the distance between the sum of the projected head entity vector and the relation vector and the projected tail entity vector, a structured embedding vector is finally calculated for each entity in the knowledge graph. In the second processing channel, the first pre-trained language model reads the policy text or enterprise description text associated with each entity, extracts the deep contextual semantic features of the text through its internal deep Transformer encoder, and generates a semantic embedding vector for each entity. The first processing channel and the second processing channel are executed synchronously, and respectively output the structural embedding vector and the semantic embedding vector corresponding to the same entity.

3. The policy intelligent matching system based on knowledge graphs according to claim 2, characterized in that: The specific operation of adaptively weighted fusing structural embedding vectors and semantic embedding vectors is as follows: First, a trainable alignment transformation matrix is ​​introduced. This alignment transformation matrix is ​​used to perform a linear transformation on the semantic embedding vector generated by the second processing channel to project the semantic embedding vector from its original semantic subspace to a new semantic subspace that is compatible with the structural embedding vector, thereby obtaining an aligned semantic vector. Secondly, a trainable dynamic weight scalar parameter is introduced to dynamically adjust the contribution ratio of the information represented by the structural embedding vector and the information represented by the semantic embedding vector in the final representation. Finally, the unified semantic representation vector is generated by the following calculation: first, a hyperbolic tangent nonlinear activation function is applied to the aligned semantic vector to transform it, resulting in a transformed semantic vector; then, the structure embedding vector and the transformed semantic vector are weighted and summed according to the contribution ratio determined by the dynamic weight scalar parameter, thereby outputting a final unified semantic representation vector with fixed dimensions that integrates dual information.

4. The policy intelligent matching system based on knowledge graphs according to claim 3, characterized in that: In the aforementioned association reasoning module, the specific execution process of the graph neural network model through multi-round message passing and neighbor information aggregation is as follows: In each round of message passing, the graph neural network model processes each entity node in the knowledge graph. For each entity node that is the current processing target, its input feature is the feature vector from the previous iteration. For the first iteration, this input feature is the unified semantic representation vector output by the knowledge encoding module. First, based on the current feature vector of the target entity node itself and the current feature vectors of each of its first-order neighbor entity nodes, an attention coefficient representing the importance of the neighbor entity node to the current target entity node is calculated. The specific calculation process is as follows: The current feature vector of the target entity node and the current feature vector of its first-order neighbor entity nodes are each multiplied by a trainable parameter weight matrix defined in this round of message passing to perform a linear transformation. The feature representation of the target entity node obtained after the linear transformation is concatenated with the feature representation of the neighbor entity node to form a combined feature vector. The combined feature vector is then multiplied by a trainable attention vector defined in this round of message passing. Finally, a leaky linear rectified unit activation function is applied to the result of the dot product to introduce nonlinearity and output the attention coefficient. Subsequently, the attention coefficients of all neighboring entity nodes are normalized using the Softmax function to obtain the normalized attention weights for each neighboring entity node. Finally, the feature vectors of each neighboring entity node are linearly transformed by the trainable parameter weight matrix, and then weighted and summed according to their corresponding normalized attention weights to obtain the neighbor message vector of the current target entity node in this round of aggregation.

5. The policy intelligent matching system based on knowledge graphs according to claim 4, characterized in that: The specific process of outputting the contextualized enhancement vector corresponding to each node in the knowledge graph is as follows: After obtaining the aggregated neighbor message vector, the features of the entity node currently being processed are updated. The feature update process is as follows: the feature vector of the entity node that is currently being processed is multiplied by a first trainable parameter weight matrix defined in this round of message passing to obtain a first linear transformation result; at the same time, the aggregated neighbor message vector is multiplied by a second trainable parameter weight matrix defined in the same round of message passing to obtain a second linear transformation result. The first linear transformation result is added to the second linear transformation result, and then a nonlinear activation function is applied to the result to generate a new feature vector of the entity node that is currently the processing target. The The new feature vector will be used as the input feature vector for the next round of message passing and aggregation operations; the process of message passing, neighbor aggregation and node feature update is repeated as a whole iterative step, and is executed repeatedly for a predetermined total number of layers; the final new feature vectors corresponding to each entity node obtained after the last iteration constitute a final feature vector set, and each vector in the set is defined as a contextual enhancement vector.

6. The policy intelligent matching system based on knowledge graphs according to claim 5, characterized in that: In the intelligent matching module, the interaction weights between the features of both parties are calculated through a cross-attention mechanism, and based on this, policy feature vectors and enterprise feature vectors enhanced with mutual attention are generated. The specific process is as follows: First, a linear transformation is performed on one contextualized augmentation vector representing a policy entity node and another contextualized augmentation vector representing an enterprise entity node from the final feature vector set output by the related reasoning module, generating their respective query vector set, key vector set, and value vector set. Next, based on a multi-attention head mechanism, in each attention head, the query vector set from the policy entity node and the key vector set from the enterprise entity node interact. Using a trainable bilinear transformation matrix defined in that attention head, the bilinear interaction score between the policy entity node query vector and the enterprise entity node key vector is calculated. This score serves as the initial attention weight for focusing on enterprises from a policy perspective, and the initial attention weight for focusing on policies from an enterprise perspective is symmetrically calculated. Then, the initial attention weights from the policy perspective and the initial attention weights from the enterprise perspective are normalized by applying the row-wise Softmax function to form standardized policy-to-enterprise attention weight matrices and enterprise-to-policy attention weight matrices, respectively. Subsequently, the value vector groups of enterprise entity nodes are weighted and summed using the policy-to-enterprise attention weight matrix to obtain the enterprise context information fused with the policy entity nodes, and the policy context information fused with the enterprise entity nodes is obtained symmetrically. Finally, for each attention head in the multi-attention head mechanism, a corresponding learnable gating scalar is introduced. The importance of the enterprise context information generated by each attention head is weighted using this learnable gating scalar. The enterprise context information corresponding to all attention heads after weighting by the learnable gating scalars is concatenated to form an aggregated context vector. This aggregated context vector is multiplied by a trainable output projection matrix to obtain the projected aggregated context. The projected aggregated context is added to the original policy entity node contextual enhancement vector to achieve a residual connection. Layer normalization is applied to the vector obtained after the residual connection to output the final cross-attention enhanced policy feature vector. Using the same symmetrical steps, the policy context information of enterprise entity node fusion and the original enterprise entity node contextualized enhancement vector are processed to generate enterprise feature vectors with mutual attention enhancement.

7. A policy intelligent matching system based on knowledge graphs according to claim 6, characterized in that: The specific process of concatenating the mutual attention-enhanced policy feature vector and the mutual attention-enhanced enterprise feature vector and inputting them into the first multilayer perceptron model to calculate the refined matching score is as follows: First, the element-wise product between the policy feature vector enhanced by mutual attention and the enterprise feature vector enhanced by mutual attention is calculated to obtain an element-wise product vector. Simultaneously, the absolute values ​​of the corresponding element-wise differences between the policy feature vector enhanced by mutual attention and the enterprise feature vector enhanced by mutual attention are calculated to obtain an absolute difference vector. Then, the policy feature vector enhanced by mutual attention, the enterprise feature vector enhanced by mutual attention, the element-wise product vector, and the absolute difference vector are concatenated along the feature dimension to form a high-order interaction feature vector. Next, the high-order interaction feature vector is input into the first multilayer perceptron model, which consists of multiple fully connected layers stacked sequentially. The intermediate layers use nonlinear activation functions to perform layer-by-layer nonlinear transformation and feature abstraction on the high-order interaction feature vector through the multiple fully connected layers. Finally, the last fully connected output layer of the first multilayer perceptron model maps the deeply abstracted features into a scalar value, which is the refined matching score between the policy and the enterprise.

8. The policy intelligent matching system based on knowledge graphs according to claim 7, characterized in that: The specific process of locating and outputting key matching evidence based on interaction weights is as follows: First, the policy-to-enterprise attention weight matrices and enterprise-to-policy attention weight matrices corresponding to each attention head generated during the calculation of interaction weights are aggregated to generate a comprehensive policy-enterprise interaction attention graph. Next, in the comprehensive policy-enterprise interaction attention graph, key interaction locations representing strong associations are selected based on a preset weight threshold. Then, the selected key interaction locations are mapped back to entities and attributes in the original knowledge graph. Specifically, the policy-side feature dimensions corresponding to the key interaction locations are associated with entities and attributes in the knowledge graph describing specific policy clauses or conditions; the enterprise-side features corresponding to the key interaction locations are... The system identifies dimensions and associates them with entities and attributes in the knowledge graph that describe enterprise qualifications or operating indicators. Based on these associations, it generates natural language evidence fragments describing the relationship between these key policy provisions and enterprise qualifications. Simultaneously, based on the policy entity node set and enterprise entity node set associated with the key interaction locations, it extracts a minimum connected subgraph in the knowledge graph that connects all relevant nodes in the policy entity node set and the enterprise entity node set. This minimum connected subgraph visually displays the core knowledge association path supporting this matching decision. Finally, it integrates the natural language evidence fragments with the minimum connected subgraph to output a structured key matching evidence report.

9. A policy intelligent matching system based on knowledge graphs according to claim 8, characterized in that: In the federated optimization module, each client trains the global model locally using private data and calculates the update amount of the trainable parameters of the global model. During training, a consistency constraint is introduced to address the differences between the trainable parameters of the local global model and the trainable parameters of the received global model. The specific process is as follows: In each round of training in federated learning, each client receives the current global model parameters from the central server. The client then trains its model locally using its private dataset, initialized with these received global model parameters. The number of samples in the private dataset constitutes the client's local data volume. During training, the client constructs a loss function consisting of two parts: the first part is the task loss; the second part is the consistency comparison loss. The construction and calculation process of the consistency comparison loss is as follows: After obtaining the feature representation of the sample through forward propagation of the model, a trainable lightweight projector is used to map this feature representation to a subspace dedicated to contrastive learning. Two different random data augmentation operations are applied to the same batch of training data samples to obtain two sets of augmented samples, and the corresponding two sets of projected feature representations are obtained through the projector. The projected feature representations from two different augmented views of the same sample are formed into a positive sample pair, and the pairings between projected feature representations from different samples are formed into a negative sample pair. The similarity between the features of the positive sample pairs is calculated. At the same time, the similarity between the feature representation generated by the currently trained local model for the original unaugmented sample and the feature representation generated by the frozen global model corresponding to the received current global model parameters for the same original sample is calculated, and this similarity is incorporated into the loss calculation as a consistency regularization term. The task loss and the consistency contrastive loss are weighted and summed according to a preset balance coefficient to form the total local training loss of the client. The client minimizes the total loss of the local training by optimizing the algorithm, calculates the updated local model parameters, and then calculates the update amount of the local model parameters relative to the received current global model parameters.

10. A policy intelligent matching system based on knowledge graphs according to claim 9, characterized in that: The central server aggregates the update amounts of the trainable parameters of the global model from all clients, generates and distributes new trainable parameters for the global model, and the specific process is as follows: The central server receives the model parameter update amount reported by each client, as well as the local training quality evaluation index calculated by each client based on its local training results in this round; the local training quality evaluation index includes the performance improvement of the client's model on the local validation set after this round of local training, and the stability measure of the local training process in this round. The central server calculates a dynamic adaptive aggregation weight for each client based on the amount of local data on each client, the performance improvement, and the stability metric. The process of calculating the adaptive aggregation weight is as follows: First, the performance improvement of each client is numerically normalized using the Sigmoid function; simultaneously, the stability metric of each client is numerically mapped using the hyperbolic tangent function; next, the local data volume of each client, the performance improvement after processing with the Sigmoid function, and the stability metric after processing with the hyperbolic tangent function are multiplied to obtain an intermediate weight factor used to calculate the weight of that client; then, the intermediate weight factors of all clients are summed to obtain a total; finally, the intermediate weight factor of each client is divided by the total to obtain the adaptive aggregation weight corresponding to that client; the central server performs a weighted summation of the model parameter update amounts reported by each client according to their corresponding adaptive aggregation weights to obtain the parameter update amounts of the global model; subsequently, the central server combines the currently held global model parameters with the... The parameter updates of the global model obtained by weighted summation are added together according to a preset global learning rate to generate a new round of global model parameters. The central server does not distribute all the new round of global model parameters to all clients, but adopts a selective synchronization strategy: it analyzes the changes in the trainable parameters of each part of the overall model composed of the knowledge encoding module, the association reasoning module, and the intelligent matching module in this round of aggregation, namely the first knowledge graph embedding model, the first pre-trained language model, the graph neural network model, and the first multilayer perceptron model, relative to the global model parameters in the previous round. For stable parameters whose changes are less than a preset threshold, the central server chooses not to distribute the updates of these stable parameters in the next round of federated learning, but instead instructs each client to continue to use the local parameter copies corresponding to these stable parameters held after the previous round of training in its local training. Only active parameters whose changes are greater than or equal to the preset threshold are sent to each client along with the basic parameters necessary to maintain model functionality, in order to complete the model update.

Images