Audit text classifying and filing method and system suitable for auditing large model training

Abstract

The invention provides an audit text classification filing method and system suitable for audit large model training, and relates to the technical field, the method comprises the following steps: carrying out entity identification and relation extraction on an unstructured audit document to generate a knowledge graph, and extracting a sub-graph structure as a feature representation; performing node embedding learning by using a graph neural network, generating a document vector containing structure and semantic information, and determining a document attribution category through an attention mechanism; and a natural language retrieval request can be analyzed, multi-hop path reasoning is executed, and a document corresponding to an implicitly associated extension node is obtained. The audit document classification accuracy is improved, efficient association query is realized, and the audit knowledge mining capability is enhanced.

Description

Technical Field

[0001] This invention relates to the field of technology, and in particular to a method and system for classifying and archiving audit texts suitable for training large-scale audit models. Background Technology

[0002] With the rapid growth in the scale and increasing diversification of audit data, the effective management and utilization of a large number of unstructured audit documents has become a significant challenge in auditing work. Traditional audit document management mainly relies on manual classification and keyword retrieval, which is insufficient to meet the needs of accurate classification and related querying of massive amounts of documents. As an emerging artificial intelligence application, audit big data models require high-quality classified and archived data as a training foundation to improve the model's understanding and application of audit expertise.

[0003] Existing audit document classification methods mostly employ keyword matching or simple machine learning techniques, which cannot effectively capture the professional entity relationships and implicit semantic information in audit documents, resulting in low classification accuracy and difficulty in meeting the refined classification needs of the audit professional knowledge system.

[0004] Traditional audit document retrieval systems are usually based on simple text similarity calculations, lack the ability to model complex relationships between documents, make it difficult to discover implicit connections between different documents, and cannot support multi-condition combined queries and knowledge reasoning in complex audit scenarios.

[0005] Existing audit document management systems generally lack a deep understanding of the professional knowledge structure in the audit field, making it difficult to build a unified audit knowledge representation system. This results in the inability to fully utilize prior knowledge in the audit field during document archiving and retrieval, affecting the system's ability to meet professional audit needs. Summary of the Invention

[0006] The present invention provides a method and system for classifying and archiving audit texts suitable for training large audit models, which can solve the problems in the prior art.

[0007] A first aspect of the present invention provides an audit text classification and archiving method suitable for training large audit models, comprising: Obtain a set of unstructured audit documents to be processed, perform entity recognition and relation extraction on the set of unstructured audit documents, generate a standard audit knowledge graph, and extract the subgraph structure in the standard audit knowledge graph as document feature representation; The document feature representation is learned by using a graph neural network model to perform node embedding, generating a document vector containing structural and semantic information. The similarity between the document vector and the center vector of each category in the preset audit classification system is calculated through an attention mechanism. Based on the similarity, the category to which each document belongs in the unstructured audit document set is determined. In response to a received natural language retrieval request, the intent entity and constraints in the retrieval request are parsed, and the target node matching the intent entity is located in the standard audit knowledge graph; Starting from the target node, multi-hop path reasoning is performed in the standard audit knowledge graph based on the constraints to obtain a set of extended nodes that have implicit associations with the target node, and the documents corresponding to the set of extended nodes are returned as search results.

[0008] Entity identification and relation extraction are performed on the aforementioned unstructured audit document set to generate a standard audit knowledge graph, including: Sequence labeling is used to identify the audit subject entity, audit project entity, financial account entity, and time entity in the unstructured audit document set, and entity text fragments and entity type tags are extracted; entity linking is performed on each identified entity text fragment, and different text expressions referring to the same audit object are mapped to a unified entity identifier to generate an entity set after entity disambiguation; Sentences containing at least two entities in the unstructured audit document set are extracted as candidate relation sentences; the audit relation type between entity pairs is identified by contextual semantic encoding of entity pairs, and relation instances in the form of triples are extracted; The standard audit knowledge graph is constructed by using the entities in the entity set as nodes and the relations in the relation instances as edges.

[0009] The document feature representation is learned by using a graph neural network model to perform node embedding, generating a document vector containing structural and semantic information. The similarity between the document vector and the center vectors of various categories in a preset audit classification system is calculated using an attention mechanism, including: Obtain the node feature matrix and adjacency matrix corresponding to the document feature representation; The graph convolutional layer applies a linear transformation to the neighboring nodes in the adjacency matrix that are connected to the current node, based on the edge type. The transformed neighboring nodes are then weighted, aggregated, and merged with the current node, and nonlinearly activated to generate a node embedding representation. The node embedding representation is passed layer by layer, and the node embedding vector containing multi-hop neighborhood information is output. Graph-level pooling is performed on the embedding vectors of each node in the subgraph corresponding to the document feature representation to generate the document vector; The document vector is multiplied by the center vectors of each category in the preset audit classification system to obtain the projection score of each category; the projection scores of each category are normalized to obtain the similarity.

[0010] In response to a received natural language retrieval request, the intent entity and constraints in the retrieval request are parsed, and the target node matching the intent entity is located in the standard audit knowledge graph, including: The search request is segmented and tagged with parts of speech. Named entity recognition is used to extract entity phrases representing the search object as the intent entity. The search request is semantically tagged with time range, audit type, organizational structure or amount range to form the constraints. The intent entity and the text description of each node in the standard audit knowledge graph are encoded into semantic embedding vectors respectively; the cosine similarity between the semantic embedding vector of the intent entity and the semantic embedding vector of each node is calculated to obtain the semantic matching score; the centrality index of each node in the standard audit knowledge graph is calculated as the structural importance score. The semantic matching score and structural importance score of each node are weighted and fused to generate a comprehensive similarity score; nodes with comprehensive similarity scores exceeding a preset score threshold are selected to form a candidate node set; the attribute values ​​of each candidate node in the candidate node set are verified to meet the constraints, and nodes that meet all constraints are retained as the target nodes.

[0011] Starting from the target node, multi-hop path reasoning is performed in the standard audit knowledge graph based on the constraints to obtain a set of extended nodes that have implicit associations with the target node, including: Add the target node as the starting node to the path set; in each hop iteration, obtain all outgoing edges, outgoing edge relationship types, and pointed neighbor nodes of the current path termination node; filter outgoing edge relationship types and neighbor node types according to the constraints, and retain neighbor nodes that meet the constraints. Add neighboring nodes that meet the constraints to the current path to form a new path; extract the relationship type of each edge in the new path, and calculate the semantic relevance score between the relationship type and the retrieval request; The centrality index of each node in the new path is extracted as the node importance index; the semantic relevance score is multiplied element by element with the node importance index and accumulated along the path, and then normalized to obtain the path confidence score. Paths whose confidence scores exceed a preset confidence threshold are filtered, and path termination nodes are extracted. It is determined whether the current number of hops has reached the maximum inference hop count. If not, the iteration continues; if it has, the iteration terminates. The path termination nodes obtained from each hop are summarized, and after deduplication, the extended node set is formed. The extended node set contains all nodes that have a multi-hop implicit association with the target node.

[0012] Add neighboring nodes that meet the constraints to the current path to form a new path; extract the relation types of each edge in the new path, and calculate the semantic relevance score between the relation types and the retrieval request, including: The neighbor node identifiers that meet the constraints are concatenated with the node sequence of the current path to generate a new path that extends by one hop. Record the edge identifiers in the new path that point from the current path termination node to the neighbor node; Extract the relation type labels corresponding to the edge identifiers from the standard audit knowledge graph; The relation type labels are input into a pre-trained language model to generate semantic vector representations of the relation types. The text of the retrieval request is input into the pre-trained language model to generate a semantic vector representation of the retrieval request; The semantic relevance score is obtained by calculating the inner product of the semantic vector representation of the relation type and the semantic vector representation of the retrieval request.

[0013] A second aspect of the present invention provides an audit text classification and archiving system suitable for training large audit models, comprising: The acquisition unit is used to acquire a set of unstructured audit documents to be processed, perform entity recognition and relation extraction on the set of unstructured audit documents, generate a standard audit knowledge graph, and extract the subgraph structure in the standard audit knowledge graph as document feature representation; The learning unit is used to learn node embeddings on the document feature representation using a graph neural network model, generate document vectors containing structural and semantic information, and calculate the similarity between the document vectors and the center vectors of various categories in the preset audit classification system through an attention mechanism, and determine the category to which each document in the unstructured audit document set belongs based on the similarity. The localization unit is used to respond to a received natural language retrieval request, parse the intent entity and constraints in the retrieval request, and locate the target node that matches the intent entity in the standard audit knowledge graph; The feedback unit is used to perform multi-hop path reasoning in the standard audit knowledge graph based on the constraints, starting from the target node, to obtain a set of extended nodes that have implicit associations with the target node, and return the documents corresponding to the set of extended nodes as search results.

[0014] A third aspect of the present invention provides an electronic device, comprising: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0015] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0016] The beneficial effects of this application are as follows: This invention constructs a standard audit knowledge graph by performing entity recognition and relationship extraction on unstructured audit documents, and extracts subgraph structures as document feature representations, effectively capturing key information and their inherent relationships in audit documents, making the document classification process more accurate and reliable.

[0017] This invention utilizes a graph neural network model to learn node embeddings for document feature representations, generating document vectors that integrate structural and semantic information. It also uses an attention mechanism to calculate similarity and determine the category, thereby improving the accuracy of automatic classification of audit documents and providing high-quality training data for large-scale audit models.

[0018] This invention can respond to natural language retrieval requests, parse the intent entity and constraints, and perform multi-hop path reasoning in the knowledge graph to obtain a set of extended nodes that are implicitly associated with the target node. This enables intelligent retrieval of audit documents, significantly improving the efficiency of audit work and the usability of audit documents. Attached Figure Description

[0019] Figure 1 This is a flowchart illustrating the audit text classification and archiving method applicable to the training of large audit models according to an embodiment of the present invention. Detailed Implementation

[0020] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0021] The technical solution of the present invention will be described in detail below with reference to specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0022] Figure 1 This is a flowchart illustrating an audit text classification and archiving method applicable to the training of a large audit model, as described in an embodiment of the present invention. Figure 1 As shown, the method includes: Obtain a set of unstructured audit documents to be processed, perform entity recognition and relation extraction on the set of unstructured audit documents, generate a standard audit knowledge graph, and extract the subgraph structure in the standard audit knowledge graph as document feature representation; The document feature representation is learned by using a graph neural network model to perform node embedding, generating a document vector containing structural and semantic information. The similarity between the document vector and the center vector of each category in the preset audit classification system is calculated through an attention mechanism. Based on the similarity, the category to which each document belongs in the unstructured audit document set is determined. In response to a received natural language retrieval request, the intent entity and constraints in the retrieval request are parsed, and the target node matching the intent entity is located in the standard audit knowledge graph; Starting from the target node, multi-hop path reasoning is performed in the standard audit knowledge graph based on the constraints to obtain a set of extended nodes that have implicit associations with the target node, and the documents corresponding to the set of extended nodes are returned as search results.

[0023] In one optional implementation, entity identification and relationship extraction are performed on the unstructured audit document set to generate a standard audit knowledge graph, including: Sequence labeling is used to identify the audit subject entity, audit project entity, financial account entity, and time entity in the unstructured audit document set, and entity text fragments and entity type tags are extracted; entity linking is performed on each identified entity text fragment, and different text expressions referring to the same audit object are mapped to a unified entity identifier to generate an entity set after entity disambiguation; Sentences containing at least two entities in the unstructured audit document set are extracted as candidate relation sentences; the audit relation type between entity pairs is identified by contextual semantic encoding of entity pairs, and relation instances in the form of triples are extracted; The standard audit knowledge graph is constructed by using the entities in the entity set as nodes and the relations in the relation instances as edges.

[0024] Sequence-labeled entity recognition extracts entities from unstructured audit documents using a deep learning-based named entity recognition model. The model employs a BERT-BiLSTM-CRF architecture. The BERT layer uses a 12-layer Transformer encoder with 768 hidden states, the BiLSTM layer contains a bidirectional recurrent neural network with 256 hidden units, and the CRF layer uses the BIO annotation scheme for sequence decoding. Entity type definitions cover four main categories: audit entity entities, audit project entities, financial account entities, and time entities. Each category includes subcategories. Audit entity entities include subtypes such as accounting firms, audit institutions, and audited entities. Audit project entities include subtypes such as internal control audits, financial audits, and special audits. Financial account entities include asset, liability, owner's equity, and profit and loss accounts. Time entities include time expressions such as audit period, report date, and recognition date.

[0025] The model training data was constructed through manual annotation, with the training corpus containing 50,000 audit documents, totaling 2 million annotated text sentences. Annotation quality was ensured through dual annotation and expert verification, achieving a consistency of over 95%. The training configuration used the AdamW optimizer with a learning rate of 2e-5, a batch size of 32, a gradient pruning threshold of 1.0, and 20 training epochs, achieving a validation set accuracy of 94.3%. During model inference, the input document was segmented into sentences, with each sentence having a maximum length of 512 characters. For extremely long sentences, a sliding window strategy was used, with a window overlap length of 50 characters. Entity recognition results include fields such as entity text, start position, end position, entity type, and confidence score. The confidence score was calculated using the path probability from the CRF layer.

[0026] Entity text fragment extraction is achieved through BIO (Browser Injection) tag sequence decoding. The decoding process identifies the starting position of entities marked by B tags and the continuation position of entities marked by I tags; consecutive BIO sequences constitute complete entity boundaries. Entity type tags are extracted from the tag information, with the tag format "B-entity type" and "I-entity type". After removing prefixes, the entity type information is obtained. The extraction process also includes boundary correction, ensuring that entity boundaries do not cut off complete words through word boundary alignment. The correction rules are based on word segmentation results and character boundary matching. Entity text normalization includes steps such as whitespace removal, punctuation processing, and case neutralization to ensure consistency in subsequent link matching.

[0027] The entity linking process achieves entity disambiguation through string similarity calculation and semantic embedding matching. String similarity employs a combination algorithm of edit distance and longest common subsequence (LCS), with an edit distance threshold of 2 characters and a LCS ratio threshold of 0.8. Semantic embedding matching uses a pre-trained language model to encode entity text, generating 768-dimensional semantic vectors. The degree of semantic matching is calculated using cosine similarity, with a similarity threshold of 0.85. Entity identifiers are generated in UUID format to ensure global uniqueness. Identifier mapping relationships are stored in an entity mapping table, which records information such as the original text, standard text, entity identifier, and entity type.

[0028] The entity disambiguation strategy combines rule matching and machine learning methods. Rule matching handles obvious alias relationships, such as the correspondence between abbreviations and full names, while machine learning methods handle complex semantic equivalence relationships. The disambiguation model employs a Siamese network architecture, taking entity text pairs as input and outputting equivalence probability scores. The model training data contains 100,000 pairs of equivalent and non-equivalent entity samples. Entity set construction is achieved by merging equivalent entities. The merging process retains the most common textual expressions as standard names and records all variant forms for subsequent matching. The final entity set includes 30,000 audit entity entities, 8,000 audit project entities, 1,500 financial account entities, and 50,000 time entities.

[0029] Candidate relation sentences are extracted through sentence-level entity co-occurrence detection. The extraction process traverses all sentences in the document, identifying sentences containing at least two distinct entities as candidates. Sentence segmentation employs a hybrid strategy based on punctuation and grammatical structure to ensure accurate sentence boundaries, with the average sentence length controlled between 50 and 200 characters. Entity co-occurrence detection is based on entity location information, calculating the text distance between entities; entity pairs with a distance exceeding the sentence boundary are not considered co-occurring. Candidate relation sentences must also meet grammatical integrity requirements, ensuring a complete subject-verb-object structure through dependency parsing.

[0030] Relation extraction is achieved through entity-to-context semantic encoding and a relation classification model. Semantic encoding uses the BERT model to encode candidate relation sentences, specifically marking entity location information. Entity text is surrounded by special markers [E1], [ / E1], [E2], and [ / E2] to enhance the model's ability to perceive entity location. The relation classification model employs a multilayer perceptron architecture. The input is the BERT-encoded sentence representation. The hidden layers contain three layers with 512, 256, and 128 neurons respectively. The output layer corresponds to 25 audit relation types, including audit execution, compliance requirements, risk association, and evidence support.

[0031] The relationship type definitions are constructed based on audit business logic, covering supervisory relationships between audit entities, inclusion relationships between audit projects, accounting relationships between financial accounts, and chronological relationships between time entities. The training data for the relationship classification model is constructed through a combination of remote supervision and manual annotation. Remote supervision utilizes structured relationships from the audit knowledge base to generate training samples, while manual annotation supplements complex semantic relationship samples, resulting in a total of 150,000 relationship instances in the training data. The model training employs a cross-entropy loss function, a learning rate of 1e-4, a batch size of 64, and 20 training epochs, achieving an F1 score of 87.6% on the validation set.

[0032] Triple relation instance extraction is achieved by combining relation classification results with entity pair information. Each triple consists of three components: a subject entity, a predicate relation, and an object entity. The subject and object are represented by a unified identifier after entity linking, and the predicate is determined by the prediction results of the relation classification model. The confidence score serves as the relation quality assessment indicator. Triple deduplication is achieved using a hash table, retaining the instance with the highest confidence for duplicate triples. A total of 500,000 relation instances are obtained after deduplication. Relation instances also include metadata information such as source document, sentence position, and extraction time, facilitating subsequent quality traceability and update maintenance.

[0033] The standard audit knowledge graph is constructed using a graph data structure to organize entity and relationship information. Node objects contain fields such as entity identifier, entity name, entity type, and attribute information. Attribute information includes different business attributes based on the entity type. Audit subject entities include attributes such as organizational nature, business scope, and qualification level, while financial account entities include attributes such as account code, account category, and accounting content. Edge objects contain fields such as relationship type, relationship identifier, confidence score, and creation time. Relationship types use standardized coding to facilitate subsequent queries and reasoning.

[0034] The graph storage employs a distributed graph database to achieve high-performance graph query and traversal operations. Data sharding is based on entity type, with audit subject entities and audit project entities stored in the core shard, financial account entities and time entities stored in the extended shard, and relationship edges stored according to the sharding rules of the starting node. The indexing strategy includes various index types such as node type indexes, relationship type indexes, and attribute value indexes, supporting efficient node lookups and relationship traversals. Graph updates utilize an incremental update strategy, with new entities and relationships written in real-time, and existing data updated in batches periodically, ensuring the real-time performance and consistency of the graph data.

[0035] In one optional implementation, a graph neural network model is used to learn node embeddings on the document feature representation to generate a document vector containing structural and semantic information. The similarity between the document vector and the center vectors of various categories in a preset audit classification system is calculated using an attention mechanism, including: Obtain the node feature matrix and adjacency matrix corresponding to the document feature representation; The graph convolutional layer applies a linear transformation to the neighboring nodes in the adjacency matrix that are connected to the current node, based on the edge type. The transformed neighboring nodes are then weighted, aggregated, and merged with the current node, and nonlinearly activated to generate a node embedding representation. The node embedding representation is passed layer by layer, and the node embedding vector containing multi-hop neighborhood information is output. Graph-level pooling is performed on the embedding vectors of each node in the subgraph corresponding to the document feature representation to generate the document vector; The document vector is multiplied by the center vectors of each category in the preset audit classification system to obtain the projection score of each category; the projection scores of each category are normalized to obtain the similarity.

[0036] Node embedding learning is performed on the document feature representation to generate document vectors containing structural and semantic information. The similarity between the document vectors and the center vectors of each category in the preset audit classification system is calculated through an attention mechanism.

[0037] Obtain the node feature matrix and adjacency matrix corresponding to the document's feature representation. Assuming an audit document contains 10 key entity nodes after preprocessing, each node having a 64-dimensional feature vector, the node feature matrix is ​​a 10×64 matrix. The adjacency matrix records the connection relationships between nodes, such as a "part-whole" relationship between the 1st node and the 3rd and 5th nodes, and an "attribute-entity" relationship between the 2nd node and the 4th and 6th nodes. These relationships can be determined based on semantic dependency analysis or co-occurrence frequency among entities in the document.

[0038] The system aggregates information from neighboring nodes connected to the current node in the adjacency matrix using graph convolutional layers. Taking node 1 as an example, the system detects connections to nodes 3 and 5. Different weight matrices are used for linear transformations depending on the edge type. For instance, a 32×64 weight matrix is ​​used to transform the features of neighboring nodes for "part-whole" relationships, while a different 32×64 weight matrix is ​​used for "attribute-entity" relationships. After transformation, an attention weighting mechanism is employed to weight and aggregate the information from neighboring nodes. Specifically, for node 1, the system calculates attention coefficients of 0.7 and 0.3 for nodes 3 and 5, respectively, indicating that node 3 contributes more to the information of node 1. The system multiplies the transformed features of node 3 by 0.7 and the features of node 5 by 0.3, sums them, and concatenates them with the features of node 1 itself. A new embedding representation of node 1 is then generated using the ReLU activation function.

[0039] The node embedding representation is passed layer by layer, outputting a node embedding vector containing multi-hop neighborhood information. In this embodiment, the system uses a two-layer graph convolutional network. The first layer processes first-order neighbor information as described above; the second layer further aggregates neighbor information based on the output of the first layer, enabling each node to obtain information about its second-order neighbors. For example, node 1 aggregates the information of nodes 3 and 5 in the first layer, and then aggregates the information of the neighbors of node 3 (such as node 7) and the neighbors of node 5 (such as node 9) in the second layer. In this way, the final embedding vector of each node contains the structural and semantic information of its multi-hop neighborhood. In this embodiment, each node ultimately generates a 32-dimensional embedding vector.

[0040] The system performs graph-level pooling on the node embedding vectors in the subgraph corresponding to the document feature representation to generate a document vector. A learnable self-attention pooling mechanism is then used to integrate all node information. The system first calculates the importance score for each node, such as 0.12 for node 1 and 0.08 for node 2. All node scores are normalized to weight coefficients using the Softmax function, which are then used to weight and sum the node embedding vectors. In this embodiment, the system weights and aggregates 10 32-dimensional node embedding vectors to generate a single 32-dimensional document vector. This vector contains both the semantic information of each entity in the document and preserves the structural relationships between entities.

[0041] The document vector is multiplied by the center vectors of each category in the pre-defined audit classification system to obtain the projected scores for each category. Assume the pre-defined audit classification system contains five categories: financial fraud, internal control deficiencies, compliance risks, asset management issues, and tax violations, each with a 32-dimensional center vector. The system calculates the inner product of the document vector with the center vectors of these five categories, obtaining the following projected scores: financial fraud 0.75, internal control deficiencies 0.45, compliance risks 0.32, asset management issues 0.28, and tax violations 0.20.

[0042] The projection scores for each category were normalized to obtain similarity scores. The Softmax function was then used to normalize these scores, resulting in the following similarity scores between the document and each category: financial fraud 0.42, internal control deficiencies 0.24, compliance risks 0.17, asset management issues 0.11, and tax violations 0.06. Based on these similarity results, the system can determine that the audit document primarily involves financial fraud issues, followed by internal control deficiencies.

[0043] The above-described technical implementation method can fully utilize the structural relationships and semantic information between entities in a document to generate a high-quality document representation and accurately calculate the similarity between the document and various categories in the audit classification system. This effectively improves the automatic classification accuracy of audit documents and provides intelligent decision support for audit work. In practical applications, this method achieved a classification accuracy of 92.3% on a test set of 5,000 real audit documents, an improvement of 15.7 percentage points compared to traditional methods.

[0044] In one optional implementation, in response to a received natural language retrieval request, the intent entity and constraints in the retrieval request are parsed, and a target node matching the intent entity is located in the standard audit knowledge graph, including: The search request is segmented and tagged with parts of speech. Named entity recognition is used to extract entity phrases representing the search object as the intent entity. The search request is semantically tagged with time range, audit type, organizational structure or amount range to form the constraints. The intent entity and the text description of each node in the standard audit knowledge graph are encoded into semantic embedding vectors respectively; the cosine similarity between the semantic embedding vector of the intent entity and the semantic embedding vector of each node is calculated to obtain the semantic matching score; the centrality index of each node in the standard audit knowledge graph is calculated as the structural importance score. The semantic matching score and structural importance score of each node are weighted and fused to generate a comprehensive similarity score; nodes with comprehensive similarity scores exceeding a preset score threshold are selected to form a candidate node set; the attribute values ​​of each candidate node in the candidate node set are verified to meet the constraints, and nodes that meet all constraints are retained as the target nodes.

[0045] The natural language retrieval request parsing process is implemented through a multi-layered text processing pipeline, which includes a word segmentation module, a part-of-speech tagging module, a named entity recognition module, and a semantic role tagging module. The word segmentation module employs a statistical maximum probability word segmentation algorithm, with a dictionary containing 2 million auditing-related professional terms. The segmentation granularity is controlled between 2 and 8 characters, and the processing time for a single sentence is no more than 10 milliseconds. The segmentation results are stored as a sequence of tokens, each token containing fields such as text content, start position, end position, and confidence score. The word segmentation module supports ambiguity resolution, ensuring segmentation accuracy through bidirectional verification using forward maximum matching and backward maximum matching.

[0046] The part-of-speech tagging module uses a conditional random field model to identify parts of speech. The tag set includes 32 part-of-speech categories, such as nouns, verbs, adjectives, numerals, and prepositions. The tagging model employs a 512-dimensional feature vector, with features including character-level ngrams, lexical-level ngrams, context windows, and dictionary matching. The model training data contains 500,000 tagged sentences, and the validation set accuracy reaches 95.8%. The tagging results are stored as a sequence of tags, with each tag corresponding to a lexical unit, and the tagging latency is controlled within 5 milliseconds. The tagging module has a built-in caching mechanism; the tagging results of frequently used phrases are cached in memory, with a cache capacity of 100,000 records.

[0047] The Named Entity Recognition (NER) module uses the BERT-CRF architecture to identify entity phrases in the search results. Entity types are defined as 15 audit-related entity types, including audit procedures, audit standards, accounting subjects, financial indicators, and audit evidence. The BERT model employs a 12-layer Transformer structure with 768 hidden layers and a maximum input sequence length of 512 tokens. The CRF layer uses the BIO annotation scheme, where B tags indicate the start of an entity, I tags indicate the interior of an entity, and O tags indicate non-entity entities. The model was trained using 200,000 annotated entity sentences with a learning rate of 2e-5, a batch size of 32, and 15 training epochs. The entity recognition accuracy reached 93.2%, and the recall reached 91.8%. Intent entity extraction is achieved through entity type filtering, retaining entities such as audit procedures, audit standards, and financial indicators as search targets.

[0048] The semantic role labeling module uses a deep learning model to identify constraint information in retrieval requests. Semantic roles include eight types: time arguments, type arguments, range arguments, and numerical arguments. The labeling model adopts a BiLSTM-CRF architecture, with 300-dimensional word vectors as input and two hidden layers (256 units each) in the LSTM layer. Time range recognition is achieved through time expression regularization pattern matching and semantic parsing, supporting both relative and absolute time expressions. Audit type recognition is based on a predefined audit type dictionary, which includes 12 types such as internal control audit, financial audit, and compliance audit. Organizational structure recognition is achieved through named entity recognition and organizational structure dictionary matching, supporting departmental levels and functional classifications. Amount range recognition is achieved through numerical entity recognition and range expression parsing, supporting expressions such as precise numerical values, ranges, and comparison relationships.

[0049] The intent entity semantic encoding employs a pre-trained language model to generate a 768-dimensional dense vector representation. The encoding model is based on the RoBERTa-Base architecture and undergoes domain-adaptive fine-tuning on an audit domain corpus containing 1 million audit text sentences. During encoding, the intent entity text is input into the model, and the hidden states marked with [CLS] are extracted as entity semantic embedding vectors. Vector normalization uses L2 norm normalization to ensure a vector magnitude of 1. Encoding latency is controlled within 20 milliseconds, and batch encoding is supported to optimize performance. Encoding results are cached in a distributed cache, with the cache key being the MD5 hash value of the entity text, and the cache expiration time set to 24 hours.

[0050] The standard audit knowledge graph node text description includes text fields such as node name, node description, and attribute tags. The node description is generated using a structured template, which includes standard fields such as entity definition, scope of application, and related elements. Node semantic encoding also uses the RoBERTa-Base model. The encoding process concatenates multiple text fields before inputting them into the model, with special delimiters separating the fields. The knowledge graph contains 500,000 nodes, and pre-computed semantic embedding vectors are stored in a vector database. The vector database uses FAISS indexing to accelerate similarity calculation. The vector update strategy uses incremental updates; vectors for newly added nodes are calculated in real time, while vectors for existing nodes are recalculated periodically.

[0051] Cosine similarity calculation achieves semantic matching scores through vector dot products and modulus normalization. The calculation process involves calculating the dot product between the intent entity vector and each node vector one by one. Since the vectors are normalized, the result of the dot product is the cosine similarity. The similarity score ranges from -1 to 1, with a higher score indicating a higher semantic match. Batch similarity calculation is optimized using matrix operations, processing up to 10,000 node vectors in a single calculation. Calculation results are sorted in descending order of similarity for easier subsequent filtering. Similarity calculation is accelerated using GPUs, with a single query latency controlled within 50 milliseconds.

[0052] The centrality metric calculation covers three metrics: degree centrality, betweenness centrality, and eigenvector centrality. Degree centrality is equal to the degree of a node divided by the maximum degree in the graph. Betweenness centrality is equal to the number of shortest paths passing through that node divided by the total number of shortest paths between all pairs of nodes in the graph. Eigenvector centrality is calculated using a power-law iteration algorithm. The centrality metrics are pre-calculated and stored in the graph database. The calculation uses a parallel algorithm and is updated weekly. The structural importance score is calculated as a weighted average of the three centrality metrics, with weight coefficients set to 0.3, 0.4, and 0.3, respectively. The score values ​​are normalized to the range of 0 to 1 using max-min normalization.

[0053] The overall similarity score is generated by a weighted fusion of semantic matching score and structural importance score. The fusion weights are configurable parameters, with the semantic weight set to 0.7 by default and the structural weight to 0.3 by default. The weight parameters can be dynamically adjusted according to retrieval accuracy requirements, with the semantic weight ranging from 0.5 to 0.9 and a step size of 0.1. The fusion calculation uses a linear weighting method; the overall score equals the semantic score multiplied by the semantic weight plus the structural score multiplied by the structural weight. The fusion result is also normalized to the range of 0 to 1 for easy threshold comparison and ranking.

[0054] The candidate node set is constructed using a comprehensive similarity score threshold filtering method. The default threshold is set to 0.6, but can be adjusted based on precision and recall requirements, ranging from 0.3 to 0.9, with an adjustment step of 0.1. The threshold filtering process iterates through the comprehensive scores of all nodes, retaining those exceeding the threshold to form the candidate set. The candidate set size is typically between 100 and 1000 nodes. If the set is too large, TopK filtering is used to further reduce its size, with K set to 500. Candidate nodes are sorted in descending order of comprehensive score for easier subsequent validation.

[0055] Constraint validation achieves precise filtering through candidate node attribute value matching. Time range constraint validation checks whether the effective time attribute of a node overlaps with the search time range; overlap determination uses a time interval intersection algorithm. Audit type constraint validation checks whether the audit classification attribute of a node contains the specified audit type, supporting both exact matching and hierarchical matching modes. Organizational structure constraint validation checks whether the affiliated organization attribute of a node conforms to the specified organizational scope, supporting departmental inclusion relationship determination. Amount range constraint validation checks whether the amount attribute of a node falls within the specified numerical range, supporting both open and closed interval determination methods. The validation process employs short-circuit logic; if any constraint condition is not met, the node is skipped, improving validation efficiency.

[0056] The target nodes are determined by selecting candidate nodes that pass all constraints. Nodes that pass validation are retained in the final result set. The result set is sorted by overall similarity score, providing ranking information for easier interpretation. The number of target nodes is typically between 10 and 100. If the number is too small, the score threshold is lowered for re-selection; if the number is too large, the threshold is raised or additional constraints are added. The target node set includes attribute information such as node identifier, node name, matching score, and validation status.

[0057] In one optional implementation, starting from the target node, multi-hop path reasoning is performed in the standard audit knowledge graph based on the constraints to obtain a set of extended nodes that have implicit associations with the target node, including: Add the target node as the starting node to the path set; in each hop iteration, obtain all outgoing edges, outgoing edge relationship types, and pointed neighbor nodes of the current path termination node; filter outgoing edge relationship types and neighbor node types according to the constraints, and retain neighbor nodes that meet the constraints. Add neighboring nodes that meet the constraints to the current path to form a new path; extract the relationship type of each edge in the new path, and calculate the semantic relevance score between the relationship type and the retrieval request; The centrality index of each node in the new path is extracted as the node importance index; the semantic relevance score is multiplied element by element with the node importance index and accumulated along the path, and then normalized to obtain the path confidence score. Paths whose confidence scores exceed a preset confidence threshold are filtered, and path termination nodes are extracted. It is determined whether the current number of hops has reached the maximum inference hop count. If not, the iteration continues; if it has, the iteration terminates. The path termination nodes obtained from each hop are summarized, and after deduplication, the extended node set is formed. The extended node set contains all nodes that have a multi-hop implicit association with the target node.

[0058] The multi-hop path reasoning process starts from the target node and discovers implicitly related nodes in the standard audit knowledge graph through an iterative expansion mechanism. The path set is implemented using a double-ended queue data structure, supporting efficient insertion at the head and deletion at the tail. The initial capacity is set to 1000 path objects, and it automatically expands by a factor of 1.5 when the capacity is insufficient. Each path object contains attributes such as a node sequence, an edge sequence, and a confidence score. The node sequence is a 64-bit integer array, the edge sequence is a 128-bit UUID array, and the confidence score is a 64-bit floating-point number. The target node identifier is obtained through a graph index query. The query result includes metadata such as node type, attribute values, and outgoing edge count. The query time complexity is O(log N), where N is the total number of nodes in the graph.

[0059] Each iteration employs a breadth-first traversal strategy, processing all paths at the current depth in each iteration. All outgoing edges from the terminating node of the current path are retrieved via an adjacency list. This adjacency list uses a hybrid structure of hash table and linked list, with the node identifier as the hash key and the value being a pointer to the head of the outgoing edge linked list. Outgoing edge objects contain fields such as the target node identifier, relation type identifier, edge weight, and creation timestamp. Relation type queries are performed through a relation type index table, which maintains a mapping from relation type identifiers to relation type names, semantic categories, constraint rules, and other attributes. Neighbor node information is obtained through a node attribute table, which stores attributes such as node type, business tag, centrality metric, and update time.

[0060] The constraint filtering mechanism performs multi-level filtering on outgoing edge relationship types and neighbor node types. Relationship type filtering is based on a predefined relationship whitelist, which includes relationship types such as audit associations, business dependencies, and regulatory constraints. The whitelist is stored in a configuration file and supports dynamic updates at runtime. Node type filtering determines the range of target node types based on the search intent, supporting both exact matching and fuzzy matching modes. Exact matching requires node types to be completely identical, while fuzzy matching allows parent-child relationships. The filtering process also includes loop detection, which avoids infinite loops by checking whether neighbor nodes already exist in the current path. The detection algorithm has a time complexity of O(L), where L is the length of the current path.

[0061] The append operation on eligible neighbor nodes generates a new path instance. The append process uses a copy-on-write strategy to optimize memory usage. The original path object remains unchanged; the new path object copies the node and edge sequences of the original path and appends the new node and corresponding edge to the end. Path length is limited to 10 hops; excessively long paths are automatically truncated. The new path object is allocated in a path memory pool, which uses a hierarchical management strategy: short paths are allocated in L1 layer, and long paths in L2 layer, each corresponding to a different memory block size. The total memory pool size is set to 100MB, with L1 layer occupying 60% and L2 layer occupying 40%.

[0062] The semantic relevance score calculation is based on the vector representation of a pre-trained language model. The relation type of each edge in the new path is obtained through edge sequence lookup, and the relation type label is input into the BERT-Base model to generate a 768-dimensional semantic vector. The retrieval request is also encoded using the BERT-Base model to generate a 768-dimensional semantic vector. The semantic relevance score is calculated using vector cosine similarity, with the result ranging from -1 to +1. The similarity calculation is optimized using SIMD instructions, with a single calculation taking approximately 2 microseconds. The relevance score is cached in memory, with the cache key being a combined hash value of the relation type and the retrieval request, and the cache validity period is 30 minutes.

[0063] The node centrality index extraction covers three metrics: degree centrality, betweenness centrality, and proximity centrality. Degree centrality equals the sum of a node's in-degree and out-degree; betweenness centrality represents the percentage of shortest paths passing through that node; and proximity centrality reflects the reciprocal of the average distance from a node to other nodes. The centrality metrics are pre-calculated and stored in the node attribute table, with a calculation cycle of 24 hours, employing parallel algorithms to improve computational efficiency. Centrality metric values ​​are normalized, with values ​​limited to between 0 and 1. The node importance index combines the three centrality metrics using a weighted average method, with weight coefficients set to 0.4, 0.3, and 0.3, respectively.

[0064] The path confidence score is calculated through element-wise multiplication of the semantic relevance score and the node importance index. Each edge in the path corresponds to a semantic relevance score, and each node corresponds to an importance index. Multiplying these two scores one by one yields the edge confidence component. The edge confidence components are accumulated along the path direction to form the total path confidence. A decay factor of 0.9 is applied during the accumulation process to simulate the distance decay effect. The original confidence score is normalized to its maximum value to ensure that the score ranges between 0 and 1. The normalization formula is the current path score divided by the maximum path score in the current batch. The normalization operation is performed after each hop iteration.

[0065] The path filtering mechanism filters low-quality paths based on a pre-set confidence threshold. The default confidence threshold is 0.6, which can be adjusted according to retrieval accuracy requirements, ranging from 0.1 to 0.9, with a step size of 0.1. The filtering process iterates through all paths generated by the current jump, retaining paths with confidence scores exceeding the threshold and discarding those below. The number of filtered paths is typically 20% to 30% of the original number of paths. Path termination node extraction is achieved by accessing the last element of the node sequence of the filtered path, and the extraction result is stored in a temporary node set.

[0066] The hop count control mechanism limits the inference depth through an iteration counter. The counter is initially set to 1 and increments by 1 after each hop iteration. Iteration terminates when the counter reaches the maximum inference hop count. The maximum inference hop count is set to 5 hops by default and can be adjusted between 2 and 10 hops depending on the graph size and query complexity. Iteration termination conditions also include an empty path set or the number of filtered paths falling below a minimum threshold of 10 paths. The iteration process maintains hop count statistics, recording metrics such as the number of paths generated per hop, the number of filtered paths, and the average confidence score.

[0067] The expanded node set is constructed by aggregating the terminal nodes of each hop filtering path. The aggregation process iterates through all hop filtering paths, extracts the terminal node identifiers, and stores them in a temporary list. Deduplication is performed using a hash set, where the key is the node identifier and the value is the number of times the node appears. The deduplicated node set is the final expanded node set, typically ranging in size from 100 to 1000 nodes. The expanded node set is sorted in descending order of confidence score for easier result presentation and analysis.

[0068] In one optional implementation, neighboring nodes that meet the constraints are appended to the current path to form a new path; the relation types of each edge in the new path are extracted, and the semantic relevance score between the relation types and the retrieval request is calculated, including: The neighbor node identifiers that meet the constraints are concatenated with the node sequence of the current path to generate a new path that extends by one hop. Record the edge identifiers in the new path that point from the current path termination node to the neighbor node; Extract the relation type labels corresponding to the edge identifiers from the standard audit knowledge graph; The relation type labels are input into a pre-trained language model to generate semantic vector representations of the relation types. The text of the retrieval request is input into the pre-trained language model to generate a semantic vector representation of the retrieval request; The semantic relevance score is obtained by calculating the inner product of the semantic vector representation of the relation type and the semantic vector representation of the retrieval request.

[0069] During multi-hop path reasoning, the addition of neighboring nodes that meet the constraints is achieved through a node sequence concatenation mechanism to extend the path. The current path is stored as an array of node identifiers, each of which is a 64-bit integer. The array length grows dynamically but does not exceed a preset maximum hop count limit. Neighboring node identifiers are obtained through a graph traversal algorithm based on an adjacency list data structure. Each node in the adjacency list maintains its outgoing edge set, which includes attributes such as the target node identifier, edge identifier, and relation type identifier. The constraint checking module performs a filtering operation on each neighboring node, checking whether the node type matches a predefined whitelist, whether the node attribute values ​​meet range constraints, and whether the node already exists in the current path to avoid loop formation.

[0070] When concatenating a matching neighbor node identifier with the current path node sequence, an array copying and expansion method is used. The original path array remains unchanged, and a new array is created with a length equal to the original array plus one. The original path node identifiers are copied to the first N positions, and the neighbor node identifier is filled into the last position. The time complexity of the concatenation operation is O(N), where N is the current path length, and the space complexity is also O(N). To optimize performance, the system maintains a path node buffer pool, pre-allocating a fixed-size node array to avoid frequent memory allocation and reclamation operations. The buffer pool size is set to 1000 path objects, each with a maximum length of 10 nodes, and the total memory usage is approximately 80KB.

[0071] The edge identifier recording mechanism tracks the last edge in a newly generated path. Edges pointing from the current path's terminating node to its neighboring nodes are obtained through graph query operations. The query process accesses the outgoing edge set of the starting node, matches the target node identifier, and returns the corresponding edge identifier. Edge identifiers use 128-bit UUID format to ensure global uniqueness. Edge identifier records are stored in the edge sequence attribute of the path object; this attribute is an array of edge identifiers, with a length one less than the node array length. Edge identifier recording operations are performed synchronously with node concatenation operations to ensure the integrity and consistency of the path structure.

[0072] The relation type label extraction process is based on a mapping query from edge identifiers to relation types. The standard audit knowledge graph maintains an edge attribute index table, which uses edge identifiers as the primary key and relation type identifiers, relation type labels, edge weights, etc., as attribute values. Relation type labels are in string format, using camelCase naming conventions, and their length is limited to 64 characters. The index table is implemented using a hash table data structure, with an average query time complexity of O(1). Hash collisions are resolved using a linked list method. The index table is periodically rebuilt to maintain query performance, with a rebuild cycle set to 24 hours. A double buffering mechanism is used during the rebuild process to avoid service interruptions.

[0073] The generation of relation type semantic vectors relies on the encoding capabilities of a pre-trained language model. The pre-trained language model uses the BERT-Base architecture with 768 hidden layers, 12 attention heads, and 12 layers. Relation type labels are fed into the model as input text. After lexicalization, positional encoding, and multi-layer Transformer encoding, the hidden states corresponding to the [CLS] tags are extracted as semantic vector representations. The semantic vectors are 768-dimensional and use 32-bit floating-point numbers. Batch processing is used for model inference to improve efficiency, with a batch size of 32 and a single inference time of approximately 100 milliseconds. To reduce redundant computation, the system maintains a relation type semantic vector cache with a capacity of 10,000 entries, employing an LRU eviction policy.

[0074] The generation of semantic vectors for retrieval requests follows the same encoding process. The retrieval request text is first preprocessed, including special character filtering, length truncation, and lexical normalization. The text length is limited to 512 tokens; for excessively long texts, a sliding window segmentation strategy is used, with a window size of 450 tokens and an overlap length of 50 tokens. The preprocessed text is input into a pre-trained language model to generate a 768-dimensional semantic vector representation. The retrieval request semantic vectors also employ a caching mechanism to optimize performance; the cache key is the hash value of the request text, and the cache validity period is set to 1 hour.

[0075] Semantic relevance scores are calculated using vector inner product operations. Both the relation type semantic vector and the retrieval request semantic vector are 768-dimensional real vectors. The inner product is calculated using element-wise multiplication followed by summation. The inner product result typically ranges from -1 to 1, but due to the lack of vector normalization, the actual range exceeds this interval. To improve computational efficiency, the inner product operation is optimized using the SIMD instruction set, with a single calculation time of approximately 1 microsecond. The relevance score serves as a crucial indicator for path evaluation and is used in subsequent path ranking and filtering operations.

[0076] A second aspect of the present invention provides an audit text classification and archiving system suitable for training large audit models, comprising: The acquisition unit is used to acquire a set of unstructured audit documents to be processed, perform entity recognition and relation extraction on the set of unstructured audit documents, generate a standard audit knowledge graph, and extract the subgraph structure in the standard audit knowledge graph as document feature representation; The learning unit is used to learn node embeddings on the document feature representation using a graph neural network model, generate document vectors containing structural and semantic information, and calculate the similarity between the document vectors and the center vectors of various categories in the preset audit classification system through an attention mechanism, and determine the category to which each document in the unstructured audit document set belongs based on the similarity. The localization unit is used to respond to a received natural language retrieval request, parse the intent entity and constraints in the retrieval request, and locate the target node that matches the intent entity in the standard audit knowledge graph; The feedback unit is used to perform multi-hop path reasoning in the standard audit knowledge graph based on the constraints, starting from the target node, to obtain a set of extended nodes that have implicit associations with the target node, and return the documents corresponding to the set of extended nodes as search results.

[0077] A third aspect of the present invention provides an electronic device, comprising: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0078] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0079] This invention can be a method, apparatus, system, and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of the invention.

[0080] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for classifying and archiving audit texts suitable for training large-scale audit models, characterized in that: include: Obtain a set of unstructured audit documents to be processed, perform entity recognition and relation extraction on the set of unstructured audit documents, generate a standard audit knowledge graph, and extract the subgraph structure in the standard audit knowledge graph as document feature representation; The document feature representation is learned by using a graph neural network model to perform node embedding, generating a document vector containing structural and semantic information. The similarity between the document vector and the center vector of each category in the preset audit classification system is calculated through an attention mechanism. Based on the similarity, the category to which each document belongs in the unstructured audit document set is determined. In response to a received natural language retrieval request, the intent entity and constraints in the retrieval request are parsed, and the target node matching the intent entity is located in the standard audit knowledge graph; Starting from the target node, multi-hop path reasoning is performed in the standard audit knowledge graph based on the constraints to obtain a set of extended nodes that have implicit associations with the target node, and the documents corresponding to the set of extended nodes are returned as search results.

2. The method according to claim 1, characterized in that, Entity identification and relation extraction are performed on the aforementioned unstructured audit document set to generate a standard audit knowledge graph, including: Sequence labeling is used to identify the audit subject entity, audit project entity, financial account entity, and time entity in the unstructured audit document set, and entity text fragments and entity type tags are extracted; entity linking is performed on each identified entity text fragment, and different text expressions referring to the same audit object are mapped to a unified entity identifier to generate an entity set after entity disambiguation; Sentences containing at least two entities in the unstructured audit document set are extracted as candidate relation sentences; the audit relation type between entity pairs is identified by contextual semantic encoding of entity pairs, and relation instances in the form of triples are extracted; The standard audit knowledge graph is constructed by using the entities in the entity set as nodes and the relations in the relation instances as edges.

3. The method according to claim 1, characterized in that, The document feature representation is learned by using a graph neural network model to perform node embedding, generating a document vector containing structural and semantic information. The similarity between the document vector and the center vectors of various categories in a preset audit classification system is calculated using an attention mechanism, including: Obtain the node feature matrix and adjacency matrix corresponding to the document feature representation; The graph convolutional layer applies a linear transformation to the neighboring nodes in the adjacency matrix that are connected to the current node, based on the edge type. The transformed neighboring nodes are then weighted, aggregated, and merged with the current node, and nonlinearly activated to generate a node embedding representation. The node embedding representation is passed layer by layer, and the node embedding vector containing multi-hop neighborhood information is output. Graph-level pooling is performed on the embedding vectors of each node in the subgraph corresponding to the document feature representation to generate the document vector; The document vector is multiplied by the center vectors of each category in the preset audit classification system to obtain the projection score of each category; the projection scores of each category are normalized to obtain the similarity.

4. The method according to claim 1, characterized in that, In response to a received natural language retrieval request, the intent entity and constraints in the retrieval request are parsed, and the target node matching the intent entity is located in the standard audit knowledge graph, including: The search request is segmented and part-of-speech tagged, and entity phrases representing the search object are extracted as the intent entity through named entity recognition. Semantic role labeling is performed on the search request, and time range, audit type, organizational structure or amount range are extracted to form the constraints. The intent entity and the text description of each node in the standard audit knowledge graph are encoded into semantic embedding vectors respectively; the cosine similarity between the semantic embedding vector of the intent entity and the semantic embedding vector of each node is calculated to obtain the semantic matching score; The centrality index of each node in the standard audit knowledge graph is calculated as the structural importance score; The semantic matching score and structural importance score of each node are weighted and fused to generate a comprehensive similarity score; Select nodes whose comprehensive similarity scores exceed a preset score threshold to form a candidate node set; verify whether the attribute values ​​of each candidate node in the candidate node set meet the constraints, and retain the nodes that meet all constraints as the target nodes.

5. The method according to claim 1, characterized in that, Starting from the target node, multi-hop path reasoning is performed in the standard audit knowledge graph based on the constraints to obtain a set of extended nodes that have implicit associations with the target node, including: Add the target node as the starting node to the path set; in each hop iteration, obtain all outgoing edges, outgoing edge relationship types, and pointed neighbor nodes of the current path termination node; filter outgoing edge relationship types and neighbor node types according to the constraints, and retain neighbor nodes that meet the constraints. Add neighboring nodes that meet the constraints to the current path to form a new path; extract the relationship type of each edge in the new path, and calculate the semantic relevance score between the relationship type and the retrieval request; The centrality index of each node in the new path is extracted as the node importance index; the semantic relevance score is multiplied element by element with the node importance index and accumulated along the path, and then normalized to obtain the path confidence score. Paths whose confidence scores exceed a preset confidence threshold are filtered, and path termination nodes are extracted. It is determined whether the current number of hops has reached the maximum inference hop count. If not, the iteration continues; if it has, the iteration terminates. The path termination nodes obtained from each hop are summarized, and after deduplication, the extended node set is formed. The extended node set contains all nodes that have a multi-hop implicit association with the target node.

6. The method according to claim 5, characterized in that, Add neighboring nodes that meet the constraints to the current path to form a new path; extract the relation types of each edge in the new path, and calculate the semantic relevance score between the relation types and the retrieval request, including: The neighbor node identifiers that meet the constraints are concatenated with the node sequence of the current path to generate a new path that extends by one hop. Record the edge identifiers in the new path that point from the current path termination node to the neighbor node; Extract the relation type labels corresponding to the edge identifiers from the standard audit knowledge graph; The relation type labels are input into a pre-trained language model to generate semantic vector representations of the relation types. The text of the retrieval request is input into the pre-trained language model to generate a semantic vector representation of the retrieval request; The semantic relevance score is obtained by calculating the inner product of the semantic vector representation of the relation type and the semantic vector representation of the retrieval request.

7. An audit text classification and archiving system suitable for training large-scale audit models, used to implement the method as described in any one of claims 1-6, characterized in that, include: The acquisition unit is used to acquire a set of unstructured audit documents to be processed, perform entity recognition and relation extraction on the set of unstructured audit documents, generate a standard audit knowledge graph, and extract the subgraph structure in the standard audit knowledge graph as document feature representation; The learning unit is used to learn node embeddings on the document feature representation using a graph neural network model, generate document vectors containing structural and semantic information, and calculate the similarity between the document vectors and the center vectors of various categories in the preset audit classification system through an attention mechanism, and determine the category to which each document in the unstructured audit document set belongs based on the similarity. The localization unit is used to respond to a received natural language retrieval request, parse the intent entity and constraints in the retrieval request, and locate the target node that matches the intent entity in the standard audit knowledge graph; The feedback unit is used to perform multi-hop path reasoning in the standard audit knowledge graph based on the constraints, starting from the target node, to obtain a set of extended nodes that have implicit associations with the target node, and return the documents corresponding to the set of extended nodes as search results.

8. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the method according to any one of claims 1 to 6.

9. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the method described in any one of claims 1 to 6.

Images