Archives content intelligent registration and knowledge indexing method and system based on multi-modal large model

Abstract

The application provides a file content intelligent registration and knowledge indexing method and system based on a multi-modal large model, relates to the technical field of file management, and first acquires a to-be-processed file set containing various modes such as text, image and audio, then performs cross-modal semantic unified analysis to generate a semantic feature vector set of each mode file, then generates a hierarchical structure tree of file content according to the semantic feature vector set, calls a file registration rule knowledge base to perform intelligent matching on registration items, and finally generates a complete file registration and indexing result through cross-node consistency collaborative reasoning, including standardized registration fields and knowledge indexing labels. The application improves the intelligent level of file management and the information utilization value.

Description

Technical Field

[0001] This invention relates to the field of archival management technology, and more specifically, to a method and system for intelligent recording and knowledge indexing of archival content based on a multimodal large model. Background Technology

[0002] In the field of archival management, with the rapid development of information technology, the storage formats of archives are becoming increasingly diversified, encompassing multiple modalities such as text, images, and audio. Traditional archival management methods mainly deal with single-modal archives, and have many limitations in managing multimodal archives.

[0003] For text archives, traditional cataloging methods typically rely on manual reading and extraction of key information, which is inefficient and prone to human error. For image archives, the lack of direct textual descriptions makes it difficult to accurately understand their content and effectively catalog and index them. Audio archives face similar challenges; their content understanding requires specialized speech recognition technology, and the recognition results may contain errors, affecting subsequent archive management.

[0004] Furthermore, existing record management systems often process records of different modalities in isolation, lacking cross-modal semantic understanding and correlation analysis, and failing to grasp the overall content structure and semantic information of the records. This results in inaccurate and incomplete record cataloging and indexing results, making it difficult to meet the requirements of modern record management for efficiency, accuracy, and comprehensiveness. Summary of the Invention

[0005] In view of the aforementioned problems, and in conjunction with the first aspect of the present invention, the present invention provides a method for intelligent cataloging and knowledge indexing of archival content based on a multimodal large model, the method comprising:

[0006] Obtain a set of archive files to be processed, which includes text archive units, image archive units, and audio archive units with their original storage formats; The set of files to be processed is subjected to cross-modal semantic unified parsing processing, and a first semantic feature vector set of the text file unit, a second semantic feature vector set of the image file unit, and a third semantic feature vector set of the audio file unit are generated based on a preset multimodal large model. Based on the first set of semantic feature vectors, the second set of semantic feature vectors, and the third set of semantic feature vectors, the structure of the archive content is analyzed to generate a hierarchical structure tree of the archive content corresponding to the set of archive files to be processed. The hierarchical structure tree of the archive content includes file-level nodes, case file-level nodes, and in-case metadata nodes. The knowledge base of archival cataloging rules is invoked to perform intelligent matching of cataloging items on the hierarchical structure tree of the archival content, so as to obtain a candidate set of cataloging items to be filled for each node in the hierarchical structure tree of the archival content. Based on the candidate set of the bibliographic entries, cross-node consistency collaborative reasoning is performed to generate the complete bibliographic indexing result of the set of archive files to be processed. The complete bibliographic indexing result includes standardized bibliographic fields and knowledge indexing tags corresponding to each node in the hierarchical structure tree of the archive content.

[0007] Furthermore, this invention also provides an intelligent cataloging and knowledge indexing system for archival content based on a multimodal large model, comprising: A processor; a machine-readable storage medium for storing machine-executable instructions of the processor; wherein the processor is configured to execute the above-described intelligent cataloging and knowledge indexing method for archive content based on a multimodal large model by executing the machine-executable instructions.

[0008] In another aspect, the present invention also provides a computer program product, the computer program product including machine-executable instructions stored in a computer-readable storage medium, wherein the processor of the intelligent cataloging and knowledge indexing system for archival content based on a multimodal large model reads the machine-executable instructions from the computer-readable storage medium, and the processor executes the machine-executable instructions, causing the intelligent cataloging and knowledge indexing system for archival content based on a multimodal large model to execute the aforementioned intelligent cataloging and knowledge indexing method for archival content based on a multimodal large model.

[0009] Based on the above, by acquiring a set of archive files containing various original storage formats, and using a multimodal large model to perform cross-modal semantic unified parsing, it is possible to accurately generate semantic feature vector sets for archives of different modalities. This achieves effective fusion and unified representation of semantic information from different modalities. Based on these semantic feature vector sets, the archive content structure is analyzed to generate a hierarchical structure tree, presenting the content hierarchy and logical relationships of the archives. By calling the archive cataloging rule knowledge base for intelligent matching of cataloging items, the candidate set of cataloging items can be automatically and accurately filled for each node, improving the efficiency and accuracy of cataloging. Finally, through cross-node consistent collaborative reasoning, a complete archive cataloging and indexing result is generated, including standardized cataloging fields and knowledge indexing tags. This achieves comprehensive and accurate cataloging and knowledge indexing of archive content, greatly enhancing the intelligence level of archive management and the value of information utilization. Attached Figure Description

[0010] Figure 1 This is a schematic diagram of the execution flow of the intelligent cataloging and knowledge indexing method for archive content based on a multimodal large model provided in an embodiment of the present invention.

[0011] Figure 2 This is a schematic diagram of exemplary hardware and software components of the intelligent cataloging and knowledge indexing system for archive content based on a multimodal large model provided in an embodiment of the present invention. Detailed Implementation

[0012] Figure 1 This is a flowchart illustrating an embodiment of the present invention of an intelligent cataloging and knowledge indexing method for archive content based on a multimodal large model, which will be described in detail below.

[0013] Step S110: Obtain a set of files to be processed, which includes text file units, image file units, and audio file units with original storage formats.

[0014] In this embodiment, the root directory of "XX Technology Company 2023 R&D Project Archives" stored in a specified network-connected storage device can be recursively scanned. Based on the matching results of the file extension and the pre-configured format mapping table, the files are initially divided into candidate text file units, candidate image file units, and candidate audio file units, generating three independent candidate file lists.

[0015] For each file in the candidate text archive unit list, its file header is parsed to extract the encoding format identifier. Based on the identifier, the corresponding text decoder is called to convert the file binary data into a text string. At the same time, the archive type identifier is extracted to perform preliminary classification of the text content, generating a text archive unit data object containing the original file path, text content, and type identifier.

[0016] For each file in the candidate image file unit list, its resolution parameters and color space parameters are read. According to the multimodal large model input requirements, the image is normalized for resolution, and the color space is converted to a preset standard as needed to generate an image file unit data object containing the original file path and a three-dimensional array of processed images.

[0017] For each file in the candidate audio file unit list, its sampling rate parameter and number of channels parameter are read. According to the multimodal large model input requirements, the audio is resampled, and the channels are merged or separated to convert to mono, generating an audio file unit data object containing the original file path and the processed audio two-dimensional array.

[0018] Each generated archive unit data object is assigned a globally unique temporary storage identifier, and all its fields are stored in the pending archive file collection storage area of ​​the in-memory database as key-value pairs. At the same time, an index record is created in the relational database to associate the temporary storage identifier, the original storage path, and the archive type, and the processing status field is uniformly set to "pending processing", thus forming a complete pending archive file collection and its traceable index record.

[0019] Step S120: Perform cross-modal semantic unified parsing processing on the set of files to be processed, and generate a first semantic feature vector set for the text file unit, a second semantic feature vector set for the image file unit, and a third semantic feature vector set for the audio file unit based on a preset multimodal large model.

[0020] Step S121: Parse the original storage format identifier of each file unit in the set of files to be processed, and input the text file unit, the image file unit and the audio file unit into the text input interface, the image input interface and the audio input interface of the multimodal large model respectively according to the original storage format identifier.

[0021] Read all records with a processing status of "Pending" from the "Pending File Index Table" constructed in step S115. For each record, retrieve the corresponding file unit data object from Redis based on its temporary identifier. Parse the data object to obtain its original storage format identifier, which is implicit in the file path extension. For example, ".pdf" corresponds to the text format identifier, ".png" corresponds to the image format identifier, and ".wav" corresponds to the audio format identifier. Based on this identifier, and through conditional judgment logic, forward the data stream of the text file unit to the predefined text input interface function process_text() of the multimodal large model; forward the data stream of the image file unit to the image input interface function process_image(); and forward the data stream of the audio file unit to the audio input interface function process_audio().

[0022] Step S122: In the text input interface of the multimodal large model, the text file unit is parsed for character stream and divided into chapter structures to generate a text paragraph sequence with paragraph boundary identifiers, and each text paragraph unit in the text paragraph sequence is mapped to an initial text embedding vector.

[0023] Inside the `process_text()` interface of the multimodal large model, the text content field of the text archive unit is first received; this field is a long string. The sentence boundary detection module of the natural language processing library SpaCy is called to parse this string. This module, based on a pre-trained neural network model, identifies the start and end positions of each sentence and further aggregates sentences into paragraphs based on the document's discourse structure features, such as consecutive line breaks "\n\n" or chapter heading formats. For example, for the text content of "Project Design Scheme_v2.3.pdf", after parsing, a text paragraph sequence ParaList=[Para_1, Para_2, ..., Para_P] is generated, where P represents the total number of paragraphs. For each text paragraph unit Para_p in the sequence, it is input into the embedding layer of a pre-trained BERT model. This embedding layer contains a word embedding matrix of shape V multiplied by D_bert, where V represents the vocabulary size and D_bert represents the word embedding dimension. By querying the matrix, each word in the paragraph is converted into a vector of dimension D_bert. Then, mean pooling is performed on all word vectors to obtain an initial text embedding vector TE_p, which also has dimension D_bert. Finally, the initial text embedding vectors of all P paragraphs are combined into an initial text embedding vector set TE_Set with shape P multiplied by D_bert.

[0024] Step S123: In the image input interface of the multimodal large model, visual region segmentation and key object detection are performed on the image file unit to generate an image region set containing the region location coordinates, and each image region unit in the image region set is mapped to an initial image embedding vector.

[0025] Inside the image input interface `process_image()` of the multimodal large model, image data from an image archive unit is first received, i.e., a three-dimensional array of shape W_in x H_in x C_in. This array is then input into a pre-trained Faster R-CNN object detection network. This network first extracts convolutional feature maps of the image through a ResNet-50 backbone network, with the feature map having shape W_fmap x H_fmap x C_fmap. Then, a region proposal network slides a window across this feature map to generate a series of candidate regions. Each candidate region is represented by four coordinate values: x_center (center x-coordinate), y_center (center y-coordinate), w_box (width w_box), and h_box (height h_box). Next, region pooling is performed on the candidate regions, scaling the feature map of each region to a fixed size, and then feeding it into the classifier and regressor, finally outputting a key object detection result with high confidence. Each result includes a region location coordinate vector `Reg_ij = [x_center_ij, y_center_ij, w_box_ij, h_box_ij]` and a class label. For example, for the image "Product Prototype_Interface A.png", multiple regions such as "Button" and "Input Box" might be detected. All detected regions constitute an image region set RegList=[Reg_1, Reg_2, ..., Reg_R], where R represents the total number of image regions. For each image region unit Reg_r in the sequence, the feature map of its corresponding region of interest after pooling is input into a fully connected layer. The weight matrix of this fully connected layer has a shape of F multiplied by D_fc, where F is the feature dimension of the pooled feature map and D_fc is the target embedding dimension. After mapping by the fully connected layer, an initial image embedding vector IE_r with dimension D_fc is obtained. Finally, the initial image embedding vectors of all R regions are combined into an initial image embedding vector set IE_Set with a shape of R multiplied by D_fc.

[0026] Step S124: In the audio input interface of the multimodal large model, acoustic feature extraction and phoneme boundary detection are performed on the audio file unit to generate an audio segment sequence with temporal boundaries, and each audio segment unit in the audio segment sequence is mapped to an initial audio embedding vector.

[0027] Inside the process_audio() of the audio input interface of the multimodal large model, first, it receives the audio data of the audio file unit, which is a two-dimensional array with the shape of L_samples multiplied by C_out, where C_out takes the value of 1. Perform pre-emphasis, framing, and windowing on this array. Using the Hamming window function, the audio signal is segmented into a series of overlapping audio frames, each frame with a length of F_len milliseconds and a frame shift of F_shift milliseconds. Then, extract 39-dimensional Mel-frequency cepstral coefficient features for each frame of audio data. The Mel-frequency cepstral coefficient features of all frames are combined into a feature matrix with the shape of F_num multiplied by 39, where F_num represents the total number of frames. Input this feature matrix into a pre-trained temporal convolutional network phoneme recognition model. Through multiple layers of convolution and gated linear units, this model encodes the feature matrix and outputs the probability distribution of each frame corresponding to each phoneme. Through the Viterbi decoding algorithm, find the optimal phoneme sequence and its corresponding temporal boundaries from these probability distributions. For example, for "Project Review Meeting_Fragment 1.wav", phonemes such as "welcome", "participate", "attend the meeting" may be recognized along with their start and end timestamps. Aggregate the above phonemes according to silent segments or long pauses to form a sequence of audio segments with semantics SegList = [Seg_1, Seg_2,..., Seg_S], where S represents the total number of audio segments. Each audio segment Seg_s corresponds to a continuous speech paragraph and is associated with a temporal boundary vector [time_start_s, time_end_s]. For each audio segment unit Seg_s, concatenate the Mel-frequency cepstral coefficient features of all frames it contains to form a feature sub-matrix with the shape of F_seg multiplied by 39. Input this sub-matrix into a long short-term memory network layer, which contains H_lstm hidden units. After the long short-term memory network processes the entire sequence, use the hidden state of the last time step as the context vector of the entire segment, and the dimension of this vector is H_lstm. Then, input this context vector into a fully connected mapping layer to obtain an initial audio embedding vector AE_s with the dimension of D_aud. Finally, combine the initial audio embedding vectors of all S segments into an initial audio embedding vector set AE_Set with the shape of S multiplied by D_aud.

[0028] Step S125: Input the initial text embedding vector, the initial image embedding vector, and the initial audio embedding vector into the cross-modal semantic alignment encoding layer of the multimodal large model, and perform modality-independent semantic space mapping processing on the initial text embedding vector, the initial image embedding vector, and the initial audio embedding vector through the shared parameter transformation matrix inside the cross-modal semantic alignment encoding layer to obtain the text semantic intermediate representation, the image semantic intermediate representation, and the audio semantic intermediate representation in the unified semantic space.

[0029] The initial embedding vector sets TE_Set, IE_Set, and AE_Set obtained from steps S122, S123, and S124, respectively, are concatenated into a large multimodal embedding vector set Multi_Set. This set is then input into a cross-modal semantic alignment coding layer, which is essentially a multilayer perceptron with shared weights. This multilayer perceptron contains two fully connected layers: the first layer has a weight matrix W_shared1 with a shape of D_in multiplied by D_hidden and a bias vector b_shared1; the second layer has a weight matrix W_shared2 with a shape of D_hidden multiplied by D_out and a bias vector b_shared2. D_in differs for text, image, and audio; for text, D_in equals D_bert; for image, D_in equals D_fc; and for audio, D_in equals D_aud. However, the weight parameters of W_shared1 and W_shared2 are completely shared across all modal inputs. First, for each embedding vector in the input Multi_Set, whether it is text, image, or audio, a first linear transformation is performed: Hidden = activation_function(Multi_Vec·W_shared1 + b_shared1), where activation_function uses the ReLU function. Then, a second linear transformation is performed: Unified_Vec = Hidden·W_shared2 + b_shared2. After these two transformations, all initial embedding vectors from different modalities are mapped to a semantic space with a uniform dimension of D_out. After mapping, the text semantic intermediate representation Unified_TE_Set retains the same number P as TE_Set, but the dimension of each vector becomes D_out; the image semantic intermediate representation Unified_IE_Set retains the same number R as IE_Set, and the dimension of each vector is D_out; the audio semantic intermediate representation Unified_AE_Set retains the same number S as AE_Set, and the dimension of each vector is D_out.

[0030] Step S126: Utilize the self-attention mechanism module of the multimodal large model to perform cross-modal contextual interaction calculations on the text semantic intermediate representation, the image semantic intermediate representation, and the audio semantic intermediate representation to generate a semantically enhanced representation vector that integrates semantic association information between text, image, and audio modalities.

[0031] The intermediate representations Unified_TE_Set, Unified_IE_Set, and Unified_AE_Set output from step S125 are concatenated again into a long sequence Unified_Seq, with a length of P+R+S and a dimension of D_out for each element. This sequence is then input into a Transformer encoder module. This module consists of N identical layers stacked together. Each layer first contains a multi-head self-attention sub-layer. In the multi-head self-attention sub-layer, the input Unified_Seq is first mapped to a query matrix Q, a key matrix K, and a value matrix V respectively through three different linear transformation matrices W_Q, W_K, and W_V, all of which have a shape of (P+R+S) multiplied by D_out. Then, Q, K, and V are split into H heads, each with a dimension of D_out divided by H. For each head h, the attention score matrix Attention_Score_h = softmax((Q_h·K_h transpose) / sqrt(D_out divided by H)) is calculated, with a shape of (P+R+S) multiplied by (P+R+S). Next, V_h is weighted and summed using the attention score matrix to obtain the context vector for each position. The outputs of all H heads are concatenated and then subjected to a linear transformation W_O to obtain the output of the self-attention sublayer, which still has a shape of (P+R+S) multiplied by D_out. This process allows each element in the sequence (whether a text paragraph, image region, or audio segment) to aggregate information from across modalities based on its attention weights with all other elements. For example, an image region vector describing an "interface button" might receive a higher attention weight from a text paragraph vector describing "clicking the button." The output of the self-attention sublayer is then fed into the feedforward neural network sublayer after residual connection and layer normalization, finally obtaining the semantic enhancement representation vector Enhanced_Seq, whose shape is consistent with the input, still being (P+R+S) multiplied by D_out.

[0032] Step S127: Perform dimensionality compression and normalization on the semantic enhancement representation vector to generate a first semantic feature vector set corresponding to the text file unit, a second semantic feature vector set corresponding to the image file unit, and a third semantic feature vector set corresponding to the audio file unit. Each semantic feature vector in the first semantic feature vector set corresponds one-to-one with each text paragraph unit in the text paragraph sequence, each semantic feature vector in the second semantic feature vector set corresponds one-to-one with each image region unit in the image region set, and each semantic feature vector in the third semantic feature vector set corresponds one-to-one with each audio segment unit in the audio segment sequence.

[0033] The semantic enhancement vector Enhanced_Seq output in step S126 is segmented according to its original source. The first P vectors of the sequence, namely Enhanced_Seq[0:P, :], are recombined into the first semantic feature vector set Final_TE_Set, with a shape of P multiplied by D_out, where each vector Final_TE_p corresponds one-to-one with the original text segment Para_p. The next R vectors of the sequence, namely Enhanced_Seq[P:P+R, :], are recombined into the second semantic feature vector set Final_IE_Set, with a shape of R multiplied by D_out, where each vector Final_IE_r corresponds one-to-one with the original image region Reg_r. The last S vectors of the sequence, namely Enhanced_Seq[P+R:P+R+S, :], are recombined into the third semantic feature vector set Final_AE_Set, with a shape of S multiplied by D_out, where each vector Final_AE_s corresponds one-to-one with the original audio segment Seg_s. To ensure stability in subsequent processing, L2 norm normalization can be applied to the vectors within each set. Specifically, for each vector V, its L2 norm ||V||2 is calculated, and the vector is then updated by dividing V by ||V||2, ensuring that the magnitude of each vector is 1. This completes the unified cross-modal semantic parsing of the initial archive file, yielding a fine-grained and mutually aligned set of semantic feature vectors across the three modalities.

[0034] Step S130: Perform archival content structure analysis based on the first semantic feature vector set, the second semantic feature vector set, and the third semantic feature vector set to generate an archival content hierarchical structure tree corresponding to the set of archival files to be processed. The archival content hierarchical structure tree includes file-level nodes, case file-level nodes, and in-case metadata nodes.

[0035] Step S131: Input the first semantic feature vector set into the pre-trained archive content hierarchical classifier to perform preliminary determination of the archive hierarchical category to which the text archive unit belongs, and obtain the candidate hierarchical category probability distribution of the text archive unit. The candidate hierarchical category probability distribution includes the confidence score of the text archive unit belonging to the file-level category, the case file-level category, or the in-case metadata level.

[0036] The first semantic feature vector set Final_TE_Set, generated in step S127 and corresponding to the text archive units, is input into a pre-trained archive content hierarchical classifier. This classifier is a multilayer perceptron model with an input layer dimension of D_out, consistent with the dimension of each vector in Final_TE_Set. The model contains two hidden layers: the first hidden layer has H1 neurons with ReLU activation; the second hidden layer has H2 neurons with ReLU activation. The output layer is a softmax layer with three neurons, corresponding to the three categories of "document level," "case file level," and "intra-case metadata level." For each vector Final_TE_p in Final_TE_Set, it is fed into the classifier. After forward propagation, a three-dimensional probability vector Prob_p=[p_file_p, p_folder_p, p_item_p] is finally obtained from the output layer, where p_file_p, p_folder_p, and p_item_p represent the confidence scores of the text paragraph unit belonging to the file level, case file level, and in-case metadata level, respectively, and the sum of the three is 1. After processing all P paragraphs, the candidate level category probability distribution set Prob_Set=[Prob_1, Prob_2, ..., Prob_P] of the entire text archive unit is obtained.

[0037] Step S132: Based on the first semantic feature vector set and the candidate level category probability distribution, identify the text paragraph units in the text archive unit that have the function of indicating level boundaries, and extract their corresponding first semantic feature vectors. Combine the second semantic feature vectors of the image region units in the second semantic feature vector set that are associated with the text archive unit in time or space to perform cross-modal level boundary verification processing, and generate the archive unit level attribution determination result in the archive file set to be processed.

[0038] Analyze the candidate hierarchical category probability distribution set Prob_Set obtained in step S131. Set a boundary probability threshold Thresh_boundary. Iterate through Prob_Set. For each probability distribution Prob_p, if its probability p_file_p corresponding to "file level" is greater than Thresh_boundary, or its probability p_folder_p corresponding to "file level" is greater than Thresh_boundary, then the paragraph unit Para_p is determined as a potential hierarchical boundary, i.e., the beginning of a new file unit. For example, if a paragraph's content is "Chapter 1 Project Overall Design", its p_folder_p is very high, which may be a file-level title. At the same time, extract the first semantic feature vector Final_TE_p corresponding to the paragraph. Then, query the image file units and audio file units associated with the text file unit. The association can be based on filename similarity or timestamp alignment. For example, suppose there is an image named "Project Overall Design_Architecture Diagram.png", whose filename is highly related to "Chapter 1" in the text. From the second semantic feature vector set Final_IE_Set of the image archive unit, find the vector Final_IE associated with the image. Calculate the cosine similarity between Final_TE_p and Final_IE: cos_sim = (Final_TE_p·Final_IE) / (||Final_TE_p||×||Final_IE||). If this similarity also exceeds a preset cross-modal verification threshold Thresh_cross, the confidence of this paragraph as a hierarchical boundary is further enhanced. Combining all text boundary paragraphs and their cross-modal verification results, generate preliminary archive unit hierarchical classification results. For example, group multiple consecutive paragraphs, related images, and audio clips into the same archive unit and preliminarily determine their level (file level, case file level).

[0039] Step S133: Based on the hierarchical attribution determination result of the archive unit, perform preliminary clustering processing on the archive units in the set of archive files to be processed according to the subordinate relationship to obtain an initial hierarchical association set containing parent archive unit identifiers and child archive unit identifiers.

[0040] Based on the determination result of step S132, for example, "Chapter 1 Project Overall Design" and its multiple subordinate descriptive paragraphs, as well as the associated "Architecture Diagram" and "Design Discussion Recording 1", are initially clustered into a file-level archive unit named "Project Overall Design File" and assigned a temporary identifier Folder_ID_001. Simultaneously, "Chapter 2 Module Detailed Design" and its subordinate contents are initially clustered into another file-level archive unit Folder_ID_002. Within Folder_ID_002, based on finer-grained boundaries, such as the "2.1 Login Module Design" paragraph and "Login Interface Prototype Diagram", they are initially clustered into a file-level archive unit named "Login Module Design File" and assigned a temporary identifier File_ID_0021. Using the above method, a set of key-value pairs containing parent identifiers (such as Folder_ID_002) and child identifiers (such as File_ID_0021) is constructed, forming an initial hierarchical relationship set Relation_Init={(Folder_ID_001:[Paragraph P1, Image R1, Audio S1]), (Folder_ID_002:[File_ID_0021, File_ID_0022]), (File_ID_0021:[Paragraph P2.1, Image R2.1])}.

[0041] Step S134: Call the knowledge base of archival formation rules to perform logical consistency correction processing on the initial hierarchical relationship set. According to the inherent relationship rules between archival formation units, formation time and business activities recorded in the knowledge base of archival formation rules, adjust the attribution relationship between parent archival units and child archival units in the initial hierarchical relationship set to generate the corrected hierarchical relationship set.

[0042] A pre-built knowledge base for document formation patterns is invoked. This knowledge base is stored in the form of a graph database, where nodes represent entities such as "department," "personnel," "project," and "time," and edges represent relationships such as "participation" and "occurrence." For example, there is a rule in the knowledge base: a "design document" under a "project" is usually completed jointly by the "product department" and the "R&D department," and its formation time should be after the project's "initiation time." For the initial relationship in step S133, such as File_ID_0021 (login module design file), its associated text paragraphs and images are parsed, and metadata is extracted from them. The responsible party is extracted from the text content as "Zhang San (R&D department)" and the timestamp "2023-05-10." A query in the knowledge base reveals that the business activity of "login module" does indeed belong to "XX project," and "Zhang San" is a member of the "R&D department," which conforms to the rule that the "design document" is the result of the "R&D department's" participation. At the same time, the timestamp "2023-05-10" is later than the project initiation time "2023-01-01." Therefore, it is consistent with the pattern for File_ID_0021 to be assigned to Folder_ID_002 (project overall design file). Conversely, if the responsible person and time of a file are found to be significantly inconsistent with the usual pattern of its parent file, its attribution will be adjusted according to the rules in the knowledge base, for example, moving it to a more suitable parent unit. This ultimately generates a revised hierarchical relationship set, Relation_Refined.

[0043] Step S135: Analyze the first semantic feature vector, the second semantic feature vector, and the third semantic feature vector corresponding to each archive unit in the modified hierarchical association set, extract the topic semantic summary vector of each archive unit, and calculate the semantic similarity matrix between different child archive units under the same parent archive unit based on the topic semantic summary vector.

[0044] Iterate through each archive unit (whether at the file or document level) in the revised hierarchical relation set `Relation_Refined`. For each archive unit, collect the semantic feature vectors of all text paragraphs, image regions, and audio segments belonging to it. For example, for the document-level unit `File_ID_0021`, it contains the text paragraph vectors `Final_TE_21a` and `Final_TE_21b`, and the image region vector `Final_IE_21a`. Perform average pooling on these vectors to obtain a topic semantic summary vector `TopicVec_File_0021` that incorporates multimodal information. This is calculated by summing each dimension of all vectors and dividing by the total number of vectors. Perform this operation on all archive units to obtain the topic semantic summary vector set `TopicVec_Set`. Then, for all child archive units (e.g., `File_ID_0021`, `File_ID_0022`) under the same parent archive unit (e.g., `Folder_ID_002`), calculate the semantic similarity between them. The similarity calculation uses the cosine similarity formula, and all the calculation results are combined into a semantic similarity matrix Sim_Matrix_Folder_002 with shape N_child multiplied by N_child, where N_child is the total number of child file units under the parent.

[0045] Step S136: Based on the semantic similarity matrix, perform serialization and sorting processing on the child archive units under the same parent archive unit to generate child archive unit sequential arrangement information that conforms to the archive formation time logic or business logic.

[0046] The semantic similarity matrix Sim_Matrix_Folder_002 generated in step S135 is analyzed. The goal is to sort the sub-file units so that logically or temporally adjacent units are also semantically similar. First, an attempt is made to regress a temporal feature from the topic semantic summary vector of each sub-file unit. A pre-trained time series prediction model can be used to predict a normalized time sequence score (TimeScore) for each file unit based on the date entities and event order extracted from the text. For example, by analyzing text such as "V1.0 design completed on May 10th" and "V2.0 updated on May 20th" contained in the "Login Module Design File," different time scores can be assigned to File_ID_0021 and File_ID_0022. Then, the semantic similarity matrix and time scores are combined for sorting. A graph-based sorting algorithm, such as topological sorting, can be used, but here it is more common to use the time score as the primary sorting criterion while using the semantic similarity matrix to correct for any potential ambiguities. For example, if two files have very similar time scores, the file that is more semantically coherent with its context (such as the preceding and following files) will be placed in a more appropriate position based on their similarity in the semantic similarity matrix. This ultimately generates an ordered list of sub-file units; for example, for Folder_ID_002, its sub-order is [File_ID_0021, File_ID_0022, ...], which conforms to the business logic or chronological order of the project from preliminary design to detailed design.

[0047] Step S137: Combine the modified hierarchical relationship set and the sequential arrangement information of the sub-file units to construct the framework of the hierarchical structure tree of the file content. The framework of the hierarchical structure tree of the file content is stored in a tree data structure, wherein each node corresponds to a file unit and records its parent node identifier and child node list.

[0048] Based on the hierarchical relationship set `Relation_Refined` corrected in step S134, and combined with the child file unit sequence information generated in step S136, a tree-like data structure is constructed in memory. A root node is created, for example, representing "XX Technology Company 2023 R&D Project Files", identified as `Root_ID`. All file units determined to be at the file level (such as `Folder_ID_001`, `Folder_ID_002`) are traversed, and they are treated as direct children of the root node, added to the root node's child node list according to project stage or formation time. Then, for each file-level node, its sorted list of file-level file units is used as its child node list. For example, for the `Folder_ID_002` node, its child node list is `[File_ID_0021, File_ID_0022, ...]`. For each file-level node, if there is more granular in-volume metadata (such as individual tables or images), it is further added as a child node. The resulting tree-like framework has each node storing its unique identifier, its parent node identifier (the root node's parent node identifier is empty), and an ordered list of child node identifiers. The entire framework's data structure can be a nested dictionary or a graph composed of node objects.

[0049] Step S138: Assign a node type identifier to each node in the framework of the hierarchical structure tree of the archive content. The node type identifier is determined according to the hierarchical classification result of the archive unit and is specifically divided into file-level node identifiers, case file-level node identifiers and in-case metadata node identifiers.

[0050] Traverse each node in the tree framework constructed in step S137. Based on the node's hierarchical affiliation determination result in step S132, assign it a type identifier. For example, for the node Folder_ID_001 representing "Project Overall Design File," assign the file-level node identifier "Type_Folder." For the node File_ID_0021 representing "Login Module Design File," assign the file-level node identifier "Type_File." For the node representing a specific image, "Login Interface Prototype," if it exists as a child node of File_ID_0021, assign the volume-level metadata node identifier "Type_Item." These identifiers are stored as strings in the node's attribute fields.

[0051] Step S139: The first set of semantic feature vectors, the second set of semantic feature vectors, and the third set of semantic feature vectors are used as node attribute information and are respectively associated and stored in the attribute fields of the corresponding text type nodes, image type nodes, and audio type nodes in the hierarchical structure tree of the archive content, forming a hierarchical structure tree of archive content that includes node hierarchical structure and node semantic content.

[0052] The entire tree structure is traversed again. For each node, based on the file unit it represents, all fine-grained semantic feature vectors corresponding to that unit are found. For example, for the file-level node File_ID_0021, it may be associated with multiple text paragraph vectors (from Final_TE_Set) and one image region vector (from Final_IE_Set). These vectors are stored as a list in the attribute field of the File_ID_0021 node as an attribute named "semantic_vectors". Simultaneously, for easier subsequent processing, all these vectors can be averaged to generate a node-level semantic vector Node_Vec_File_0021 representing the overall semantics of the node, which is also stored as an attribute. For nodes containing only a single modality of content, such as a volume metadata node that is an image, its corresponding second semantic feature vector Final_IE_r is directly stored in its attribute. Thus, each tree node not only contains hierarchical structure information (parent and child relationships), but also rich, multi-granular semantic content information, forming a complete hierarchical structure tree for archive content, Hierarchy_Tree.

[0053] Step S140: Call the archive cataloging rule knowledge base to perform intelligent matching processing of cataloging items on the hierarchical structure tree of the archive content, and obtain the candidate set of cataloging items to be filled for each node in the hierarchical structure tree of the archive content.

[0054] Step S141: Traverse each node in the hierarchical structure tree of the archive content, and generate a multidimensional feature description vector for the node based on the node type identifier of the node and the first semantic feature vector, second semantic feature vector or third semantic feature vector associated with the node. The multidimensional feature description vector integrates the semantic content information of the node and its hierarchical position information in the hierarchical structure tree of the archive content.

[0055] A depth-first traversal is performed on the hierarchical structure tree (Hierarchy_Tree) constructed in step S139. For each node encountered, such as a file-level node (Folder_ID_002), the node-level semantic vector (Node_Vec_Folder_002) is first obtained from its attributes. This vector has a dimension of D_out. Then, the node's hierarchical depth information in the tree is obtained. The root node depth is set to 0, the file-level node depth to 1, the file-level node depth to 2, and the volume-level metadata node depth to 3. The depth value (Depth) is one-hot encoded to obtain a vector (Depth_Vec) with a dimension of D_depth, where D_depth equals the maximum depth plus 1 (4 here). Only the element at the corresponding depth position in this vector is 1, and the rest are 0. At the same time, the node's type identifier (e.g., "Type_Folder") is obtained and also one-hot encoded to obtain a vector (Type_Vec) with a dimension of D_type, where D_type equals the total number of types (3 here). Finally, the node-level semantic vector Node_Vec_Folder_002, the depth encoding vector Depth_Vec, and the type encoding vector Type_Vec are concatenated to form a multi-dimensional feature description vector Feature_Node_Folder_002, with dimensions D_out + D_depth + D_type. This vector simultaneously integrates the semantic content of the node, its absolute position in the tree, and the node category information.

[0056] Step S142: Input the multidimensional feature description vector of the node into the record item matching engine of the record record rule knowledge base. The record record rule knowledge base pre-stores a set of record item templates corresponding to various record types and the record item field name, record item field data type and record item field filling constraint rules contained in each record item template.

[0057] The node multidimensional feature description vector Feature_Node generated in step S141 is input into a bibliographic item matching engine. This engine is connected to a knowledge base of document bibliographic rules. This knowledge base predefines various document types, such as "Project Feasibility Study Report," "Software Design Specification," and "Meeting Minutes." For each document type, there is a corresponding bibliographic item template. Taking the "Software Design Specification" template as an example, it contains a list of fields, each containing the following information: the bibliographic item field name is "Responsible Person," the field data type is "String," and the filling constraint rule is "must be selected from the project team member list"; the bibliographic item field name is "Design Date," the data type is "Date," and the filling constraint rule is "Format is YYYY-MM-DD, and no later than the project completion date"; the bibliographic item field name is "Design Module Name," the data type is "String," and the filling constraint rule is "must highly match the chapter title in the document." All templates and their field constraint rules are stored in the knowledge base in structured data form.

[0058] Step S143: In the bibliographic item matching engine, calculate the matching similarity between the multidimensional feature description vector of the node and the template feature vector of each bibliographic item template in the archive bibliographic rule knowledge base. The template feature vector is pre-generated based on the semantic description of the archive type, forming unit and business scope applicable to the bibliographic item template.

[0059] The bibliographic item matching engine first loads the template feature vectors of all bibliographic item templates in the knowledge base. Each template feature vector is generated during the knowledge base construction phase by inputting the template's description information (such as "design specification applicable to software projects, the responsible department is usually the R&D department") into the text encoding part of the same multimodal large model as in step S127. Its dimension is the same as the dimension of the node's multidimensional feature description vector Feature_Node, both being D_total. Then, for the current node's Feature_Node, the engine calculates its cosine similarity with each template feature vector Temp_Vec_t: Match_Score_t=(Feature_Node·Temp_Vec_t) / (||Feature_Node||×||Temp_Vec_t||). This calculation process traverses all T templates in the knowledge base, resulting in a matching similarity list Match_Scores=[Match_Score_1, Match_Score_2, ..., Match_Score_T].

[0060] Step S144: Sort the bibliographic item templates in descending order according to the matching similarity, and select the bibliographic item templates with matching similarity exceeding a preset similarity threshold as the candidate bibliographic item template set for the node.

[0061] The Match_Scores list generated in step S143 is sorted from largest to smallest. A matching similarity threshold, Thresh_match, is set. From the sorted list, all templates with Match_Score_t greater than Thresh_match are selected as the candidate bibliographical item template set for that node. For example, for the node Folder_ID_002, the similarity of the "Software Design Specification" template might be 0.95, and the similarity of the "Project Summary Report" template might be 0.60. If Thresh_match is set to 0.90, then only the "Software Design Specification" template will be selected into the candidate set. If no template exceeds the threshold, the top K templates with the highest similarity are selected as candidates, where K is a preset positive integer, for example, K is 3. The candidate template set Cand_Temp_Set_Folder_002 contains the selected template identifiers and their corresponding matching similarities.

[0062] Step S145: Parse each candidate bibliographic item template in the candidate bibliographic item template set, extract the sequence of bibliographic item field names contained in each candidate bibliographic item template and the filling constraint rules corresponding to each bibliographic item field name. The filling constraint rules include data type constraints, value range constraints and association mapping rules with the semantics of the archive content of the field values.

[0063] For each template in the candidate bibliographic item template set obtained in step S144, such as the candidate template Temp_SoftwareDesign, its complete definition is read from the knowledge base. This definition is parsed to extract the sequence of bibliographic item field names contained in the template, for example, Field_List=[“Responsible Person”, “Design Date”, “Design Module Name”, “Version Number”, “Reviewer”]. For each field name in the field list, such as “Design Module Name”, its associated value constraint rules are further extracted. These rules might be expressed as: data type constraint is “string”, value range constraint is “none”, and the association mapping rule with the semantics of the archive content is “find phrases highly related to keywords such as ‘design module’ and ‘chapter title’ in the text paragraphs corresponding to the semantic feature vector of the node.” The rule for another field, “Reviewer”, might be: data type is “string”, value range constraint is “must belong to the ‘Review Committee List’”, and the association mapping rule is “find the volume metadata named ‘Review Comments’ in the associated child nodes of the node and extract the reviewer’s signature from it.”

[0064] Step S146: For each field name of a field name in each candidate field name template, according to the filling constraint rules corresponding to the field name, retrieve the candidate filling content that matches the field name of the field name from the multidimensional feature description vector of the node and the semantic feature vector of the child or parent node associated with the node in the hierarchical structure tree of the archive content.

[0065] Taking the node Folder_ID_002 and its candidate template Temp_SoftwareDesign's field "Design Module Name" as an example. First, according to its association mapping rules, it is necessary to search within the semantic content of the node. The semantic vector Node_Vec_Folder_002 of node Folder_ID_002 is an abstraction of its main content, but for accurate matching, it is necessary to backtrack to its original fine-grained vector. Traverse the semantic feature vectors of all child nodes (file-level nodes, such as File_ID_0021) under this node, and perform keyword retrieval on the text paragraph vector Final_TE_p under the above child nodes. The retrieval is not based on string matching, but on semantics. The field name "Design Module Name" itself is also converted into a query vector Query_Field through a text encoder. Then, the cosine similarity between Query_Field and each text paragraph vector Final_TE_p is calculated. The paragraphs with the highest similarity, such as the paragraphs containing "2.1 Login Module Design" and "2.2 Registration Module Design", are extracted as candidate values ​​"Login Module" and "Registration Module". Simultaneously, according to the rules of the "Reviewer" field, it is necessary to search for a node named "Review Comments" among its child nodes. Assume that node Folder_ID_002 has a file-level node named File_ID_0023 with the type identifier "Type_File," and through semantic matching, its topic is highly relevant to "Review Comments." Then, the text content of this child node is parsed, and using named entity recognition technology, the names "Li Si" and "Wang Wu" are extracted as candidate values ​​for the "Reviewer" field.

[0066] Step S147: Organize the candidate fill-in contents according to their source node identifiers and the confidence scores calculated during the retrieval process, and generate a fill-in candidate list corresponding to each field name of each bibliographic item under each candidate bibliographic item template. Each candidate item in the fill-in candidate list contains the fill-in content text and a description of the source path of the fill-in content text.

[0067] For the multiple candidate values ​​retrieved for each field in step S146, they are organized and scored. For example, for the field "Design Module Name", two candidate values ​​are obtained: "Login Module" and "Registration Module". A confidence score is calculated for each candidate value. This score can be based on the semantic similarity calculation result; for example, the similarity score for "Login Module" is 0.98, and the similarity score for "Registration Module" is 0.95. Simultaneously, the source path of each candidate value is recorded. For "Login Module", its source node identifier is File_ID_0021, and the specific source is the text paragraph index p_idx_21 under this node. Organize the above information into a data structure, such as a list: Field_ModuleName_Cand_List=[{"value":"Login Module","confidence":0.98","source_node":"File_ID_0021","source_detail":"Paragraph Index p_idx_21"},{"value":"Registration Module","confidence":0.95","source_node":"File_ID_0022","source_detail":"Paragraph Index p_idx_22"}]. Perform this operation on all fields to obtain a list of candidate values ​​for each field.

[0068] Step S148: Gather all candidate bibliographic item templates and their corresponding bibliographic item field names and candidate values ​​to form the bibliographic item filling candidate set of the node. The bibliographic item filling candidate set records multiple possible bibliographic item template selection schemes and multiple possible filling values ​​for each bibliographic item field under each scheme.

[0069] Finally, all candidate bibliographic item templates and their associated information for the current node Folder_ID_002 are integrated into a structured set, namely the bibliographic item filling candidate set for this node. This set can be represented as a nested data structure. The outer layer is a list, and each element in the list corresponds to a candidate template. Inside each template element, there is a template identifier field, a template matching similarity field, and an inner dictionary. The keys of this dictionary are field names, and the values ​​are the candidate lists of the corresponding fields (such as the list generated in step S147). For example, for the node Folder_ID_002, its bibliographic item filling candidate set Cand_Set_Folder_002 may look like this: containing one element, the template identifier is "Temp_SoftwareDesign", the template matching similarity is 0.95, and the field mapping dictionary is {"Design Module Name": Field_ModuleName_Cand_List, "Reviewer": Field_Reviewer_Cand_List, ...}. Traverse all nodes in the Hierarchy_Tree and generate such a bibliographic item filling candidate set Cand_Set_Node for each node.

[0070] Step S150: Based on the candidate set of the bibliographic entries, perform cross-node consistency collaborative reasoning to generate the complete bibliographic indexing result of the set of archive files to be processed. The complete bibliographic indexing result includes standardized bibliographic fields and knowledge indexing tags corresponding to each node in the hierarchical structure tree of the archive content.

[0071] Step S151: Summarize the candidate sets of the bibliographic items of all nodes in the hierarchical structure tree of the archive content, and construct a global bibliographic candidate state space diagram with the hierarchical structure tree of the archive content as the skeleton. Each node in the global bibliographic candidate state space diagram corresponds to a hierarchical structure tree node of the archive content. The state of each node is composed of the currently selected candidate bibliographic item template identifier and the selected filling value of each bibliographic item field.

[0072] Based on the hierarchical structure tree Hierarchy_Tree generated in step S139 and the candidate set Cand_Set_Node for filling bibliographic entries generated for each node in step S148, a global bibliographic candidate state space graph State_Graph is constructed. The topology of this graph is identical to that of Hierarchy_Tree. Each node in the graph (called a state node) corresponds to a node in Hierarchy_Tree. Each state node contains a "current state" variable. This state variable is a composite data structure containing two parts: the first part is the currently selected candidate bibliographic entry template identifier Cur_Temp_ID; the second part is a dictionary Cur_Field_Values, where the keys are the field names defined in the template, and the values ​​are specific values ​​selected from the candidate list corresponding to that field. Initially, the state of each node is empty.

[0073] Step S152: Initialize the state of each node in the global cataloging candidate state space graph, randomly assign a candidate cataloging item template identifier to each node, and randomly select a filling value from the corresponding filling candidate list for each cataloging item field under the candidate cataloging item template to form the initial state of the node.

[0074] To initiate the collaborative reasoning process, the state of each node in the State_Graph needs to be initialized. Iterate through all nodes in the State_Graph. For each node, such as the node corresponding to Folder_ID_002, randomly select a candidate entry template from its entry population candidate set Cand_Set_Folder_002. Assume the randomly selected template identifier is “Temp_SoftwareDesign”. Then, iterate through each field under this template. For the field “Design Module Name”, randomly select a candidate from its corresponding value candidate list Field_ModuleName_Cand_List, for example, “Login Module”. Similarly, randomly select a candidate for the “Reviewer” field, for example, “Li Si”. Combine all these random selections to form the initial state of the node: Cur_Temp_ID = “Temp_SoftwareDesign”, Cur_Field_Values ​​= {“Design Module Name”: “Login Module”, “Reviewer”: “Li Si”, ...}. Assign this initial state to the corresponding node in the State_Graph. After this operation is performed on all nodes, the State_Graph is in a completely random initial state.

[0075] Step S153: Based on the pre-stored consistency constraints of the cataloging items in the archival cataloging business rule base, construct a cross-node collaborative reasoning objective function for cataloging items. The consistency constraints of the cataloging items include the logical consistency constraints of the cataloging item field values ​​among the file-level nodes under the same case file-level node, the uniformity constraints of the same semantic cataloging item field values ​​among different nodes, and the matching constraints of the cataloging item field values ​​and the hierarchical relationship of the hierarchical structure tree of the archival content.

[0076] A database of archival cataloging rules is invoked to extract consistency constraints to guide collaborative reasoning, and a global objective function is constructed accordingly. This objective function aims to evaluate the rationality and consistency of the current state of the entire State_Graph. Examples of constraints are as follows: First, logical consistency constraints on the field values ​​of cataloging items among file-level nodes under the same case file-level node. For example, for files File_ID_0021 and File_ID_0022 under case file Folder_ID_002, the date of their "Design Date" field on the file-level node must be later than the "Project Initiation Date" on the case file-level node, and the dates among the file-level nodes should be in chronological order. Second, consistency constraints on the values ​​of cataloging items with the same semantic meaning across different nodes. For example, if the "Responsible Person" field appears in multiple file-level nodes and refers to the same person, the name description must be consistent (it cannot be "Zhang San" in one place and "Zhang Gong" in another). Third, constraints on the matching of cataloging item field values ​​with the hierarchical structure tree of archival content. For example, the "Content Summary" field of a case file-level node should be a summary of the content of all its child nodes, rather than the specific details of a single child node. The above constraints can be quantified into individual penalty or reward items; for example, violating logical consistency increases the penalty value P_unity, while consistent expression is rewarded with the value R_consistency. The global objective function F_total can be expressed as the weighted sum of all penalty and reward items; a smaller value (or a larger value, depending on the definition) indicates a better overall state.

[0077] Step S154: Perform a graph-based collaborative reasoning iterative update process on the global cataloging candidate state space graph. In each iteration, a target node is randomly selected. Based on the cataloging item template identifier and cataloging item field filling content corresponding to the current state of the target node's adjacent nodes in the archive content hierarchical structure tree, calculate the local conditional probability when the target node selects different candidate cataloging item templates and different filling content.

[0078] The iterative update process begins. In each iteration, a node is randomly selected from the State_Graph as the target node, denoted as Node_target. The adjacent nodes of Node_target in the tree are examined, namely its parent node, all child nodes, and sibling nodes. The current state of these adjacent nodes (i.e., their currently selected template and fill value) is obtained. Based on the states of these adjacent nodes and the global objective function F_total constructed in step S153, the local conditional probability of Node_target in this iteration if it chooses a specific state (i.e., a specific template and corresponding fill value combination) from its candidate set Cand_Set_Node_target is calculated. The core idea of ​​this probability calculation is to select a state that maximizes consistency with adjacent nodes. Specifically, for each possible state candidate s of Node_target, the value of the local item F_local(s) related to Node_target and its adjacent nodes in the global objective function F_total is calculated when the current adjacent node state is fixed. The probability P(s) can be defined as being proportional to exp(-F_local(s)), meaning that the smaller the local objective function value (the higher the consistency), the greater the probability of a state being selected. After calculating P(s) for all candidate states s, a probability distribution is formed.

[0079] Step S155: Update the current state of the target node according to the local conditional probability. The updated state of the target node will replace its original state and affect the calculation of the local conditional probability of other adjacent nodes in subsequent iterations.

[0080] Based on the local conditional probability distribution P(s) calculated in step S154, the current state of Node_target is updated using sampling. This is typically done using a roulette wheel selection method, where a random number between 0 and 1 is generated, and the state chosen as the new state of Node_target is determined by the probability interval of which the random number falls within. For example, if the probability P(s1) of state s1 is 0.6, the probability of s2 is 0.4, and the random number is 0.3, then s1 is selected. The current state of Node_target is then updated to the selected new state. This updated state takes effect immediately and changes the local configuration of the State_Graph, thus affecting the calculation of local conditional probabilities in subsequent iterations when its neighboring nodes are selected as target nodes.

[0081] Step S156: Repeat the collaborative reasoning iterative update process until the state of all nodes in the global cataloging candidate state space graph tends to be stable. The criterion for determining the stability is that the overall cataloging item consistency constraint satisfaction of the global cataloging candidate state space graph no longer changes significantly in multiple consecutive iterations.

[0082] Repeat steps S154 and S155 for thousands of iterations. After each iteration, the global objective function F_total for the entire State_Graph can be calculated. As iterations proceed, the value of F_total will typically decrease gradually (if defined as a penalty value) and eventually converge to a lower level. A convergence criterion is set, for example, that in N_rounds of consecutive iterations (e.g., N_rounds is 100), the difference between the maximum and minimum values ​​of the global objective function F_total is less than a preset convergence threshold Thresh_converge. When this condition is met, the states of all nodes in the graph are considered to have stabilized, indicating a globally coordinated and highly consistent cataloging scheme.

[0083] Step S157: When the state of the global cataloging candidate state space graph tends to be stable, extract the final selected cataloging item template identifier and the final filled value of each cataloging item field from the final stable state of each node to form a set of standardized cataloging fields for each node in the hierarchical structure tree of the archive content.

[0084] After the iteration stops, the current state of each node in the State_Graph is the final stable state. Traverse all nodes and read the final selected candidate bibliographic item template identifier (Final_Temp_ID) and the final determined field value dictionary (Final_Field_Values) from the state variables of each node. For example, for the node Folder_ID_002, its Final_Temp_ID is "Temp_SoftwareDesign", and its Final_Field_Values ​​are {"Design Module Name": "Login Module", "Reviewer": "Li Si, Wang Wu", "Design Date": "2023-05-20", ...}. Combining this template identifier and the field value dictionary constitutes the standardized bibliographic field set Std_Metadata_Node for that node. This set is structured, clearly defining which bibliographic rule template the archival unit should follow and the specific values ​​to be filled in for each rule field.

[0085] Step S158: Based on the standardized record field set of each node and the first semantic feature vector, second semantic feature vector or third semantic feature vector of the node, call the preset knowledge indexing rule base to perform knowledge unit extraction and indexing processing, and generate knowledge indexing tags corresponding to the standardized record field of the node. The knowledge indexing tags include subject term tags, classification number tags and entity name tags.

[0086] Step S1581: Parse the standardized record field set of each node, and extract the record field names and corresponding record field values ​​that have entity type indication function in the standardized record field set. The record field names that have entity type indication function include the responsible person field name, the time field name, the location field name, and the subject field name.

[0087] For each node's standardized cataloging field set Std_Metadata_Node obtained in step S157, such as node Folder_ID_002, its field dictionary Final_Field_Values ​​is parsed. Fields whose names themselves indicate a certain entity type are identified. For example, a field named "Responsible Person" has the corresponding values ​​"Zhang San, Li Si"; a field named "Design Date" has the value "2023-05-20"; and a field named "Related Project" has the value "XX Technology Company 2023 Annual R&D Project". The field names and their values ​​that indicate type are extracted to form a list of entities to be processed: Entity_Extract_List = [("Responsible Person", "Zhang San"), ("Responsible Person", "Li Si"), ("Design Date", "2023-05-20"), ("Related Project", "XX Technology Company 2023 Annual R&D Project")].

[0088] Step S1582: Input the name of the recording field that has the function of indicating entity type and the corresponding recording field value into the entity recognition rule matcher of the knowledge indexing rule base. The knowledge indexing rule base pre-stores the recognition rule templates corresponding to different entity types and the mapping relationship with the dictionary of archival domain terms.

[0089] The entity list to be processed generated in step S1581, Entity_Extract_List, is input into an entity recognition rule matcher. This matcher is connected to a knowledge indexing rule base. The rule base predefines recognition rules for various types of entities. For example, for the "Responsible Person" field, the corresponding entity type is usually "Person" or "Organization". There is a rule in the rule base: if the content of the responsible person is in the "List of Internal Personnel", it is determined as a "Person Entity" and mapped to a standard person name; if it is in the "List of Partner Units", it is determined as an "Organization Entity". For the "Design Date" field, its rule directly maps it to a "Time Entity" and it must be formatted in the standard ISO8601 date format. For "Associated Project", its rule is: query the project database; if a match is found, it is determined as a "Project Entity", and its standard project name and project number are obtained.

[0090] Step S1583: In the entity recognition rule matcher, the candidate entity type is initially determined based on the record field name, and the precise or fuzzy matching is performed in the archival domain terminology dictionary in combination with the record field value to generate the entity type determination result and entity standard name of the node.

[0091] Based on the rules in step S1582, the matcher begins processing. For the entry (“Responsible Person”, “Zhang San”), the candidate entity type pointed to by the field name “Responsible Person” is “Person”. The matcher uses “Zhang San” as the query term and performs an exact match in the terminology dictionary of “Internal Personnel Directory” attached to the knowledge indexing rule base. If the match is successful, the standard name “Zhang San” and its employee ID are returned. For the entry (“Responsible Person”, “XX Technology Company”), the field name is the same, but the filled value is successfully matched fuzzily in the “Cooperating Unit Directory”, and it is determined to be an “Organizational Entity”, with the standard name “XX Technology Co., Ltd.”. For the entry (“Related Project”, “XX Technology Company 2023 Annual R&D Project”), a fuzzy match is performed in the project database, and the standard name of the project “XX Technology Company 2023 Annual R&D Project” is successfully matched, and its project code “XM-2023-001” is obtained. Finally, an entity type determination result (such as “Person”, “Organization”, “Project”) and an entity standard name are generated for each entry.

[0092] Step S1584: Based on the entity type determination result and entity standard name of the node, and combined with the first semantic feature vector, second semantic feature vector or third semantic feature vector of the node, perform semantic association retrieval in the topic term table of the knowledge indexing rule base, and calculate the semantic similarity between the semantic feature vector of the node and the topic term vector of each topic term in the topic term table.

[0093] To generate topic tags, the semantic content of nodes needs to be associated with a standard thesaurus. The node-level semantic vector Node_Vec_Folder_002 of node Folder_ID_002 is retrieved. A thesaurus is loaded from the knowledge indexing rule base. Each topic term in this thesaurus (e.g., "software design", "project management", "user interface") is pre-encoded into a topic vector Topic_Vec_t using the same multimodal large model. Its dimension is the same as Node_Vec_Folder_002, D_out. The entire thesaurus is traversed. For each topic vector Topic_Vec_t, its cosine similarity to Node_Vec_Folder_002 is calculated: Topic_Sim_t = (Node_Vec_Folder_002 · Topic_Vec_t) / (||Node_Vec_Folder_002|| × ||Topic_Vec_t||). After the calculation is completed, a Topic_Sim_List of topic similarity is obtained, which records the semantic similarity between a node and each standard topic word.

[0094] Step S1585: Select the topic words whose semantic similarity exceeds the preset topic word similarity threshold as candidate topic word tags for the node, and sort the candidate topic word tags according to the semantic similarity to determine the final topic word tags used for indexing.

[0095] Set a topic similarity threshold, Thresh_topic. From the Topic_Sim_List generated in step S1584, filter out all topics with Topic_Sim_t greater than Thresh_topic to form a candidate topic tag list. Then, sort this list in descending order of similarity. To control the granularity of indexing, a maximum of K_topic topics can be selected as the final topic tag. For example, assuming the similarity of "software design" is 0.92, the similarity of "project management" is 0.88, and the similarity of "user interface" is 0.85, Thresh_topic is set to 0.80, and K_topic is set to 3, then the final topic tag will be these three.

[0096] Step S1586: Parse the values ​​of the recorded fields in the standardized recorded field set of the node related to the subject or business domain of the archive content, call the classification number mapping table of the knowledge indexing rule base, and convert the recorded field values ​​of the subject or business domain into the corresponding archive classification number tags.

[0097] The generation of archival classification numbers primarily relies on standardized descriptive fields that specify the discipline or business domain. For example, in the standardized descriptive fields of node Folder_ID_002, there is a field named "Business Domain" with the value "Software Development". The classification number mapping table in the knowledge indexing rule base is then called. This table is a collection of key-value pairs, where the key is the business domain or discipline name, and the value is the corresponding classification number. For example, "Software Development" might map to "TP311.5" (the Software Engineering category in the Chinese Library Classification). If the mapping table matches directly, the classification number "TP311.5" is directly obtained. If not, semantic matching may be required to find the closest classification number. Finally, the archival classification number label for this node, Class_Label="TP311.5", is generated.

[0098] Step S1587: Gather the entity standard name, the subject term tag, and the archive classification number tag to form a preliminary knowledge indexing tag set for the node.

[0099] Step S1587-1: Based on the entity type determination result of the node, extract the standard names of personal names, institutional names, place names, and time entities from the standard entity names, and store the standard names of personal names, institutional names, place names, and time entities into the corresponding subsets of personal name tags, institutional tags, place names, and time entities in the preliminary knowledge indexing tag set, respectively.

[0100] The entity type determination results and standard names obtained from step S1583 will be classified and stored. For node Folder_ID_002, its entity identification results include: personal name entities “Zhang San” and “Li Si”; organization entity “XX Technology Co., Ltd.”; time entity “2023-05-20”; and project entity “XX Technology Company 2023 Annual R&D Project” (which can be classified into organization-related entities or set up as a separate project entity subset). The above entities will be stored in different subsets under the Prelim_Label_Set of the Preliminary Knowledge Indexing Labels, for example, Person_Entities=[“Zhang San”, “Li Si”], Org_Entities=[“XX Technology Co., Ltd.”], Time_Entities=[“2023-05-20”].

[0101] Step S1587-2: Based on the semantic similarity ranking results between the semantic feature vector of the node and the topic word vector of each topic word in the topic word table, select the top-ranked topic words as preferred topic word tags, and store the preferred topic word tags and their word family relationship information in the topic word table into the topic word tag subset of the preliminary knowledge indexing tag set. The word family relationship information includes the hypernyms, hyponyms and related words of the preferred topic word tags.

[0102] The topic tags determined in step S1585, such as "software design," "project management," and "user interface," are stored in the topic tag subset Topic_Entities of Prelim_Label_Set. Simultaneously, for each selected topic, its word family relationships are queried from the topic term table. For example, for "software design," its superordinate term is "computer technology," its hypothetical terms are "architecture design" and "detailed design," and its related term is "software development." This relationship information is also stored as metadata, associated with the topic tags, to facilitate subsequent knowledge discovery and retrieval.

[0103] Step S1587-3: Parse the hierarchical structure of the archive classification number tags, extract the classification category identifier, classification sub-category identifier, and classification detail identifier corresponding to the archive classification number tags, and store the classification category identifier, the classification sub-category identifier, and the classification detail identifier in the classification number tag subset of the preliminary knowledge indexing tag set after organizing them according to the hierarchical relationship.

[0104] The file classification label Class_Label="TP311.5" obtained in step S1586 is parsed. According to the classification rules, its hierarchical structure is parsed out: the major category is "TP" (Industrial Technology), the minor category is "TP3" (Computing Technology, Computer Technology), the subcategory is "TP311" (Programming, Software Engineering), and the most specific category is "TP311.5" (Software Engineering). These hierarchical identifiers are organized into a string or structured object according to their hierarchical relationships and stored in the classification label subset Class_Entities of Prelim_Label_Set, for example, {"Major Category": "TP", "Minor Category": "TP3", "Subcategory": "TP311", "Full Text Category": "TP311.5"}.

[0105] Step S1587-4: Based on the node type identifier of the node and the depth information of the node in the hierarchical structure tree of the archive content, determine the indexing depth level of the node in the knowledge indexing system, and add the indexing depth level as a metadata tag to the preliminary knowledge indexing tag set.

[0106] The level of detail in indexing is automatically determined based on the node's type and depth. For example, a case-level node Folder_ID_002, with a depth of 1 and a type of "Type_Folder", can be assigned an indexing depth level of "case-level summary indexing". Meanwhile, its subordinate file-level node File_ID_0021, with a depth of 2 and a type of "Type_File", can be assigned "file-level detailed indexing". This level information is also added to the Prelim_Label_Set as a metadata label, Index_Level.

[0107] Step S1587-5: Combining the title citation field values ​​and abstract citation field values ​​in the standardized citation field set of the node, extract the core keywords from the title citation field values ​​and abstract citation field values, and perform semantic association matching between the core keywords and the preferred subject term tags. Add the successfully matched core keywords as supplementary subject term tags to the subject term tag subset.

[0108] From the standardized bibliographic fields of node Folder_ID_002, obtain the value of the "Title" field ("Software Design Specification for Project XX") and the value of the "Abstract" field ("This document describes the overall software design, module division, and interface definition of Project XX"). Extract keywords from the above text, potentially obtaining core keywords such as "overall design," "module division," and "interface definition." Perform semantic association matching between these keywords and existing preferred subject term tags (such as "software design"). Calculate the similarity between "overall design" and "software design." If the similarity exceeds a threshold, "overall design" can be added as a supplementary subject term tag to the subject term tag subset, thereby enriching the fine-grainedness of indexing.

[0109] Step S1587-6: Format and encapsulate all subsets of person name entity tags, organization entity tags, place name entity tags, time entity tags, subject term tags, and classification number tags in the preliminary knowledge indexing tag set to generate a preliminary knowledge indexing tag set data structure with internal structured organization.

[0110] Finally, all the above subsets and metadata information are integrated and formatted to form a complete, structured preliminary knowledge indexing tag set, Prelim_Label_Set_Folder_002. This set is a JSON-like nested data structure that clearly contains various entities, keywords, classification numbers, and their attributes.

[0111] Step S1588: Perform redundancy and consistency checks on the preliminary knowledge indexing tag set, delete tags with semantic repetition or logical conflict in the preliminary knowledge indexing tag set, and perform hierarchical inheritance and supplementation processing on the tags in the preliminary knowledge indexing tag set according to the hierarchical relationship between parent nodes and child nodes in the hierarchical structure tree of the archive content to generate the final knowledge indexing tags.

[0112] Perform a quality check on Prelim_Label_Set_Folder_002. First, check for internal redundancy. For example, if the subject term tag already contains "software design," while the supplementary keyword tag contains "software design methods," and the two are highly semantically overlapping, consider deleting the latter and retaining the more standard superordinate term. Second, check for logical conflicts. For example, if the classification number tag is "TP311.5" (software engineering), but the subject term tag contains "mechanical design," the cause needs to be traced back, as there may be an error. After confirmation, delete or correct the conflicting tags. Then, perform knowledge enhancement using a hierarchical structure tree. Check the final knowledge indexing tags of the parent node (root node) of Folder_ID_002. If the parent node has the subject term "project management," but Folder_ID_002 itself does not, according to the hierarchical inheritance rule (child nodes should inherit some core topics from the parent node), "project management" can be added to the tag set of Folder_ID_002, but can be marked as "inherited from the parent node." Conversely, examining the labels of its child node File_ID_0021 reveals that if the child node has a more granular "Login Module Design," according to the induction rules, "Login Module Design" can be considered a subtopic of Folder_ID_002. However, it is usually not directly categorized at the case file level but rather retained at the file level. Through the above checks, corrections, inheritance, and supplementation, the final, high-quality knowledge indexing label set Final_Label_Set_Folder_002 is generated.

[0113] Step S159: Associate and encapsulate the standardized record field set and corresponding knowledge indexing tag of each node in the hierarchical structure tree of the archive content to generate the complete record indexing result of the archive file set to be processed. The complete record indexing result is organized with the hierarchical structure tree of the archive content as the organizational framework. Each node in the tree carries its finally determined standardized record field set and knowledge indexing tag.

[0114] Step S1591: Create a bibliographic indexing record unit for each node in the hierarchical structure tree of the archive content. The bibliographic indexing record unit includes a node identifier field, a node type identifier field, a standardized bibliographic field set storage area, and a knowledge indexing tag storage area.

[0115] Before generating the final result, a unified data structure is first defined—the bibliographic indexing record unit. For each node in the hierarchical structure tree of the archive content, a corresponding record unit is created. Taking node Folder_ID_002 as an example, its record unit Record_Folder_002 is a data container containing four parts: the node identifier field stores "Folder_ID_002"; the node type identifier field stores "Type_Folder"; the standardized bibliographic field set storage area stores the Std_Metadata_Node obtained in step S157; and the knowledge indexing label storage area stores the Final_Label_Set_Node obtained in step S1588.

[0116] Step S1592: Store the standardized record field set of each node in the standardized record field set storage area of ​​the record indexing record unit in the form of key-value pairs of record field name and record field value, and retain the source path description information of each record field value in the record field filling candidate set as traceability metadata.

[0117] The standardized record field set Std_Metadata_Folder_002 of node Folder_ID_002, which is a dictionary containing field names and values, is stored in the standardized record field set storage area of ​​Record_Folder_002. To ensure the traceability of the indexing results, for each field value, in addition to the final value itself, a source metadata field is also attached. This metadata records which source node and source fragment the value comes from in the candidate list of values ​​in step S147. For example, for the "Design Module Name" field, the source metadata for its value "Login Module" is {"source_node":"File_ID_0021","confidence":0.98}. In this way, when subsequent auditing or correction is required, the source basis of the indexing value can be clearly known.

[0118] Step S1593: Store the knowledge indexing tags of each node in the knowledge indexing tag storage area of ​​the recording unit according to the tag type. The knowledge indexing tag storage area is divided into an entity tag storage sub-area, a subject term tag storage sub-area, and a classification number tag storage sub-area. For each knowledge indexing tag, record the rule identifier or model version information on which it was generated.

[0119] The final knowledge indexing tag set Final_Label_Set_Folder_002 of node Folder_ID_002 is stored in the knowledge indexing tag storage area of ​​Record_Folder_002. During storage, it is strictly organized according to its internal structure: personal entities, organizational entities, etc., are placed in the entity tag storage sub-area; subject terms and their word family relationships are placed in the subject term tag storage sub-area; and classification number hierarchical information is placed in the classification number tag storage sub-area. Simultaneously, to enhance credibility and maintainability, a "generation basis" metadata is associated with each tag. For example, for the subject term "software design," the associated metadata could be "rule: subject term matching, model version: MultiModalModel_v2, similarity threshold: 0.80." For the entity "Zhang San," the associated metadata could be "rule: responsible person field - personnel directory exact match, rule version: EntityRule_v3."

[0120] Step S1594: Establish pointer links between the parent node and child node indexing record units in the hierarchical structure tree of the archive content, so that the indexing record unit of any node can access the indexing record units of its parent node and all its child nodes through the pointer links.

[0121] After creating the indexing record units for all nodes, the hierarchical relationships between them need to be reconstructed. For each record unit in the tree, such as Record_Folder_002, two pointer fields are added based on its parent-child relationship in the Hierarchy_Tree: a parent node pointer, Parent_Pointer, pointing to the record unit of its parent node (this pointer is null for the root node); and a child node list pointer, Child_Pointers, which is a list containing pointers to all its direct child record units. In this way, the originally scattered record units are reorganized into a pointer tree with the exact same structure as the original tree. This allows for convenient navigation and hierarchical access in the final indexing result, such as directly accessing all file record units under a single file record unit.

[0122] Step S1595: Based on the original storage path and archival group number information of the set of archives to be processed, generate the file header identification information of the complete archival cataloging result. The file header identification information includes the archival group number identifier, the archival catalog number identifier, and the archival formation time range descriptor.

[0123] Generate the header information for the entire indexing result package. Read the record group number of the batch of archives from the system configuration, for example, "Fonds_XXTech_2023". Generate an archive catalog number, for example, "Dir_2023_RD", based on the original storage path " / storage / project_archives / ". By scanning the metadata of all archive units, determine the formation time range of this batch of archives, for example, from the earliest "2023-01-10" to the latest "2023-12-15". Combine the above information into the header identification information Header_Info={"Fonds_ID":"Fonds_XXTech_2023","Catalog_ID":"Dir_2023_RD","Time_Range":"2023-01-10 / 2023-12-15"}.

[0124] Step S1596: The file header identification information and the cataloging record units of all nodes are serialized and assembled to generate a complete archive cataloging result data packet with a self-describing structure. The data format of the complete archive cataloging result data packet is compatible with the data exchange standard of the archive management system.

[0125] For example, step S1596-1: Construct the root node of the complete archive cataloging indexing result data packet according to the preset archive data exchange format specification. The root node includes a version declaration field and a namespace declaration field.

[0126] Begin assembling the final data package. Based on the data exchange standard of the archive management system, such as a custom specification based on JSON, first construct a root object, Root_Package. In the root object, first write the version declaration field "version": "1.0" and the namespace declaration field "xmlns:arch": "http: / / www.archive-standard.org / ns".

[0127] Step S1596-2: The file header identification information is serialized and written as a child node of the root node. The file header identification information child node contains a file collection number sub-element, a file catalog number sub-element, and a file formation time range sub-element. Each sub-element corresponds to an element label and an element value.

[0128] In the root object Root_Package, create a sub-object named "Header". Fill this sub-object with the information from Header_Info generated in step S1595, forming a structure like "Header":{"Fonds_ID":"Fonds_XXTech_2023","Catalog_ID":"Dir_2023_RD","Time_Range":"2023-01-10 / 2023-12-15"}.

[0129] Step S1596-3: Traverse all nodes in the hierarchical structure tree of the archive content, and create a recording indexing record unit node for each node as a child node of the root node. The recording indexing record unit node includes a node identifier attribute and a node type identifier attribute.

[0130] In the root object `Root_Package`, create an array named "Records". Then, iterate through the `Hierarchy_Tree`. For each node encountered, such as `Folder_ID_002`, create a JSON object `Record_Node`. In this object, first set its properties, such as `node_id`: "Folder_ID_002", `node_type`: "Type_Folder".

[0131] Step S1596-4: Inside each cataloging index record unit node, create a standardized cataloging field set node, and convert all key-value pairs in the standardized cataloging field set storage area of ​​the node into cataloging item child nodes one by one. Each cataloging item child node contains the cataloging item field name attribute and the cataloging item field value text content.

[0132] Inside the Record_Node object, create a sub-object named "StandardMetadata". Then, iterate through each key-value pair (field name, field value) in the standardized bibliographic field set Std_Metadata_Folder_002 stored in step S1591, adding it directly as an attribute of the "StandardMetadata" object, for example, "StandardMetadata":{"Design Module Name":"Login Module", "Reviewer":"Li Si, Wang Wu",...}. Simultaneously, if traceability information is needed, a parallel "MetadataProvenance" object can be created to store the traceability metadata for each field.

[0133] Step S1596-5: Within each cataloging record unit node, create a knowledge indexing tag set node, and within the knowledge indexing tag set node, create entity tag sub-nodes, subject term tag sub-nodes, and classification number tag sub-nodes according to the tag type. Write the corresponding knowledge indexing tags into the corresponding tag type sub-nodes. Each tag sub-node contains tag name attribute and tag value text content.

[0134] Inside the Record_Node object, create a sub-object named "KnowledgeLabels". Within this sub-object, create three more sub-objects: "Entities", "Topics", and "Classifications". Write the tags stored in step S1593 into each sub-object. For example, "KnowledgeLabels":{"Entities":{"Person":["Zhang San", "Li Si"], "Organization":["XX Technology Co., Ltd."]}, "Topics":["Software Design", "Project Management"], "Classifications":{"Full":"TP311.5", "Hierarchy":{"Major Category":"TP", "Subcategory":"TP3"}}}. Similarly, a "Provenance" metadata object can be associated with each tag or subset to record the basis for its generation.

[0135] Step S1596-6: Based on the pointer link relationship between parent nodes and child nodes established in the hierarchical structure tree of the archive content, add a parent node identifier reference field and a child node identifier list field to each recording indexing record unit node. The parent node identifier reference field points to the node identifier of its parent node, and the child node identifier list field contains a list of node identifiers of all its direct child nodes.

[0136] Inside the Record_Node object, two fields are added to explicitly represent the hierarchical relationship, instead of relying solely on memory pointers: "parent_ref": "Folder_ID_001" (if its parent node is Folder_ID_001), and "children_refs": ["File_ID_0021", "File_ID_0022"]. This way, even when the data packet is exported as plain text, its internal hierarchical structure is fully preserved through identifier references.

[0137] Step S1596-7: Perform structural validity verification on the complete archive cataloging result data packet formed after serialization and assembly, and check whether the complete archive cataloging result data packet conforms to the element nesting rules and data type definitions in the archive data exchange format specification.

[0138] After assembly, a complete JSON string is generated, namely the complete archival cataloging and indexing result data package, Raw_Result_Package. A JSONSchema validator is invoked to validate it using the Archival Data Exchange Format (ARDE) schema file. This schema defines which fields are required, the data type of each field must be a string, array, or object, and the nested hierarchical relationships. The validator checks whether the Root_Package contains "Header" and "Records," whether each Record contains the required fields, and whether the value of the "Design Date" field conforms to the date format, etc. If validation fails, an error log is logged and a return message indicates a defect in the assembly process.

[0139] Step S1596-8: After the structure validity verification is passed, the complete archive cataloging indexing result data packet is output to the designated storage location, and data packet storage path receipt information is generated. The data packet storage path receipt information includes the file name and storage path of the complete archive cataloging indexing result data packet.

[0140] After successful verification, the JSON string "Raw_Result_Package" is written to a file. The filename can be generated using the format "archival archival number_processing timestamp.json", for example, "Fonds_XXTech_2023_20240520143022.json". This file is stored in the specified output directory, such as " / output / archival_results / ". Upon successful file writing, a receipt message "Receipt_Info" is generated, containing the filename and the complete storage path " / output / archival_results / Fonds_XXTech_2023_20240520143022.json". This information is logged or returned to the calling system, marking the successful completion of the entire intelligent cataloging and knowledge indexing process.

[0141] Step S1597: Perform digital signature processing on the complete archival cataloging result data package to generate a digital digest value for verifying the authenticity of the source and the integrity of the content of the complete archival cataloging result data package, and store the digital digest value in association with the complete archival cataloging result data package.

[0142] For example, step S150 may also include: step S210: obtaining a historical archive cataloging instance library, wherein the historical archive cataloging instance library contains the complete archive cataloging indexing results of multiple historical archive units and the corresponding historical semantic feature vector set, and the complete archive cataloging indexing results of each historical archive unit record the hierarchical structure tree of the historical archive content corresponding to the historical archive unit and the set of historical standardized cataloging fields and historical knowledge indexing tags of each historical node in the tree.

[0143] In step S150 and its sub-steps, the current batch of archival cataloging and indexing results are generated through collaborative reasoning. To further improve the accuracy and consistency of the reasoning, especially for newly emerging archival types or complex archival collections, historical experience can be referenced. Therefore, it is first necessary to construct and obtain a historical archival cataloging instance library. This instance library is stored in a distributed file system, and its data organization is a series of JSON data packets archived in time batches. Each historical data packet corresponds to a historical archival processing task, and its internal structure is completely consistent with the complete archive cataloging and indexing result data packet generated in step S1596, i.e., it contains file header identification information and cataloging and indexing record units organized in a tree structure. For each historical archival unit in the instance library, in addition to storing its final standardized cataloging field set and knowledge indexing tag, it also stores the historical semantic feature vector set generated and persisted in step S127 when processing the historical archival. The aforementioned historical semantic feature vectors are also divided into first, second, and third semantic feature vector sets, corresponding to text, image, and audio modalities respectively, and are all bound to the various historical nodes in the hierarchical structure tree of the historical archival content constructed at that time. The entire instance library is indexed by an Elasticsearch search engine. The index keys include archival fonds identifiers, archival type identifiers, creation time ranges, and key entities and keywords extracted from historical knowledge indexing tags.

[0144] Step S220: Select historical archive recording instances from the historical archive recording instance library that have the same archival fonds identifier or the same archival type identifier as the current set of archive files to be processed, use the selected historical archive recording instances as a reference instance set, and assign an initial reference weight value to each reference instance in the reference instance set.

[0145] Before initiating collaborative reasoning on the current batch of archives, the system first establishes a connection with the historical archive catalog instance database. From the file header identifier information of the current batch of archives generated in step S1595, the archive fonds identifier, such as "Fonds_XXTech_2023", is extracted. Simultaneously, by analyzing the semantic features of the root node or main file-level nodes in the current archive content hierarchical structure tree (Hierarchy_Tree), the overall type identifier of the current batch of archives can be inferred, for example, "Research and Development Project Archives". Then, a query statement is constructed and sent to the Elasticsearch search engine. The search criteria are: the "archive fonds identifier" field of the historical archive records in the index exactly matches "Fonds_XXTech_2023", or the "archive type identifier" field exactly matches "Research and Development Project Archives". The search engine returns all historical archive catalog instances that meet the criteria, forming a reference instance set (Ref_Instance_Set). For each reference instance (Ref_Inst_k) in this set, an initial reference weight value (Init_Weight_k) needs to be assigned to it. The initial weights are assigned based on a preliminary estimate of the similarity between the instance and the current file. A simple strategy is to assign a higher base weight, such as Weight_High, to instances that share the exact same fonds identifier as the current file; and a lower base weight, such as Weight_Low, to instances that only share the same file type but have different fonds. The sum of the initial weights for all instances is 1.

[0146] Step S230: Parse each reference instance in the reference instance set, extract the topological structure information of the hierarchical structure tree of the historical archive content corresponding to each reference instance, and organize the historical nodes in each reference instance into a reference instance node structure tree according to the hierarchical relationship based on the topological structure information, and generate a reference node feature vector for each historical node that integrates the set of historical standardized recording fields and historical knowledge indexing tags of that historical node.

[0147] For each reference instance Ref_Inst_k in the reference instance set Ref_Instance_Set, the system reads its stored complete archive cataloging and indexing result data packet. First, it parses the "Records" array under its header. Based on the "parent_ref" and "children_refs" fields in each record unit, it reconstructs the hierarchical structure tree History_Tree_k of the historical archive content in memory. The structure of this tree is completely consistent with the Hierarchy_Tree generated in step S139. Each historical node History_Node_kj is associated with its historical standardized cataloging field set Hist_Metadata_kj and historical knowledge indexing label set Hist_Labels_kj. In order to use the knowledge of historical nodes to guide the state selection of the current node, the above information needs to be merged into a unified reference node feature vector Ref_Node_Vec_kj. The vector is generated as follows: First, all field values ​​in the historical standardized bibliographic field set Hist_Metadata_kj are concatenated into a long text string, for example, "Responsible person: Zhang San, Design date: 2023-05-20, Design module name: Login module". Then, this string is input into the text encoding part of the same multimodal large model as in step S127, outputting a semantic vector Meta_Vec_kj. Simultaneously, from the record of this historical node, the historical semantic feature vector Hist_Semantic_Vec_kj, which represents its core semantics and was generated during historical processing (this vector was initially generated and stored in step S127), is retrieved. Finally, these two vectors are concatenated to form the final reference node feature vector Ref_Node_Vec_kj, with dimensions D_semantic plus D_meta. This vector contains both the content semantics of the historical node and its final assigned bibliographic indexing semantics.

[0148] Step S240: In each iteration update process of the cross-node consistent collaborative reasoning, obtain the node semantic feature vector corresponding to the current state of each node in the global cataloging candidate state space graph in the current iteration round. The node semantic feature vector is generated by semantic encoding of the currently selected cataloging item template identifier and the cataloging item field filling content of the node.

[0149] In the iterative process of cross-node consistent collaborative reasoning described in steps S154 to S156, consideration of historical reference instances is introduced. At the beginning of each iteration, for each node in the global cataloging candidate state space graph, such as Node_target, a node semantic feature vector Cur_Semantic_Vec representing its current indexing semantics needs to be generated based on its current "current state" variable. The generation process is as follows: First, obtain the candidate cataloging item template identifier Cur_Temp_ID currently selected for the node, and load the description information of the template from the knowledge base. Then, obtain the selected fill-in content Cur_Field_Values ​​for each cataloging item field in the current state. Concatenate the above information, including the template description and field values, into a text string. Input this string into the text encoding part of the same multimodal large model as in step S127, and output a vector with dimension D_semantic, which is Cur_Semantic_Vec. This vector captures in real time the semantic connotation of the cataloging indexing scheme assigned to the node in the current iteration round.

[0150] Step S250: Calculate the feature similarity between the node semantic feature vector of the target node in the current iteration and the reference node feature vector of each historical node of all reference instances in the reference instance set. Perform weighted summation based on the feature similarity and the current reference weight value of each reference instance, and select the preset number of historical nodes with the highest weighted summation similarity as similar reference nodes of the target node.

[0151] In each iteration, after selecting a target node Node_target, in addition to calculating the local conditional probability based on the states of its neighboring nodes, a step of referencing historical instances is added. First, the cosine similarity between the current node semantic feature vector Cur_Semantic_Vec_target of Node_target and the reference node feature vectors Ref_Node_Vec_kj of all historical nodes in the reference instance set Ref_Instance_Set is calculated, resulting in a large similarity matrix Sim_Matrix, where each element Sim_target_kj = cosine_similarity(Cur_Semantic_Vec_target, Ref_Node_Vec_kj). Then, the similarity is weighted and combined with the current reference weight value Cur_Weight_k of each reference instance Ref_Inst_k (in the first iteration, this weight value is the initial weight assigned in step S220). For each historical node, its weighted similarity Weighted_Sim_kj = Sim_target_kj multiplied by Cur_Weight_k is calculated. The weighted similarity of all historical nodes is sorted in descending order, and the top N_ref historical nodes are selected as the similar reference node set Ref_Nodes_Target in this iteration. These nodes represent the most similar cataloging examples to the current state of the current node in historical cataloging practice.

[0152] Step S260: Extract the historical standardized bibliographic field set and historical knowledge indexing tag of the similar reference node from the reference instance corresponding to the similar reference node, and organize the historical standardized bibliographic field set and historical knowledge indexing tag in a structured manner according to the hierarchical position of the similar reference node in the reference instance node structure tree to generate the reference bibliographic pattern template of the target node.

[0153] For each similar reference node Ref_Node_selected selected in step S250, complete information is extracted from its corresponding reference instance Ref_Inst_selected. The historical standardized descriptive field set Hist_Metadata_selected and the historical knowledge indexing label set Hist_Labels_selected for this historical node are extracted. Simultaneously, to preserve its contextual information, the hierarchical position information of this historical node within its historical archive content hierarchical structure tree History_Tree_selected also needs to be extracted, such as the type of its parent node and the number of its child nodes. This information is then structured to form a "reference descriptive pattern template" Ref_Pattern_Target. This template is not merely a simple copy of key-value pairs, but includes field values ​​and their roles within the historical context. For example, if a similar reference node is a "file-level" node with a "design module name" field value of "login module", and this node is located under a "file-level" node with a "project name" of "XX project", then Ref_Pattern_Target will record the above hierarchical relationship. It is recommended that if the current node also selects a similar field value, then its parent node should also have the corresponding characteristics.

[0154] Step S270: Convert the correspondence between the field names and values ​​of the bibliographic entries recorded in the reference bibliographic mode template and the correspondence between the knowledge indexing tag types and tag values ​​into external consistency constraints for the selection of the current state of the target node, and add the external consistency constraints to the cross-node consistency collaborative reasoning objective function in the form of constraint terms.

[0155] The knowledge contained in the reference cataloging pattern template Ref_Pattern_Target generated in step S260 is transformed into computable external consistency constraints and integrated into the collaborative reasoning objective function F_total constructed in step S153. Specifically, for each record in Ref_Pattern_Target, for example, if the value of the field "Design Module Name" is "Login Module", a constraint can be constructed: if the target node Node_target also selects a candidate value for this field, then its matching degree with the historical example can be measured by calculating the semantic similarity between the candidate value and "Login Module". The higher the similarity, the larger the reward value (or the smaller the penalty value). Similarly, for knowledge indexing tags, such as the subject tag of the historical example containing "Software Design", if the current node also selects a semantically similar subject tag (regardless of whether it is finally determined, this is calculated based on its current state during the iteration process), it should also receive a reward. The above reward or penalty terms are added to the original objective function F_total in the form of a weighted sum to form a new enhanced objective function F_total_enhanced. Its weight is determined by the weighted similarity Weighted_Sim_kj of the reference node in step S250. The higher the similarity, the greater the influence of the example.

[0156] Step S280: Based on the collaborative reasoning objective function with added external consistency constraints, recalculate the local conditional probability of the target node when selecting different candidate bibliographic templates and different filling contents in the current iteration round, and update the current state of the target node based on the recalculated local conditional probability.

[0157] In step S154, the original local conditional probability P(s) was calculated based on the states of neighboring nodes. Now, since the objective function has been updated to F_total_enhanced, which includes the matching degree with historical examples, the local term F_local_enhanced(s) needs to be calculated based on this new enhanced objective function when calculating the local conditional probability of each possible state candidate s of the target node Node_target. The new probability P_enhanced(s) is proportional to exp(-F_local_enhanced(s)). This means that a state candidate s will receive a higher probability if it not only matches the states of its neighboring nodes but also is highly similar to high-quality historical records. Subsequently, the current state of Node_target is updated and sampled again based on the updated probability distribution P_enhanced(s). This process dynamically combines historical experience with the current context.

[0158] Step S290: After each iteration update, based on the matching degree between the state of all nodes in the current iteration and the overall reference instance set, dynamically adjust the current reference weight value of each reference instance in the reference instance set, so that reference instances with higher semantic similarity to the overall set of files to be processed in the current iteration receive a larger reference weight value.

[0159] After each iteration, not only is the node state updated, but the weights (Cur_Weight_k) of each instance in the reference instance set also need to be dynamically adjusted, as the relevance of historical instances may change as the state graph evolves. At the end of the iteration, the overall state vector (Overall_State_Vec) of the entire State_Graph is calculated. This vector is obtained by average pooling the node semantic feature vectors (Cur_Semantic_Vec) of all nodes. Simultaneously, for each reference instance (Ref_Inst_k), its overall representative vector (Overall_Ref_Vec_k) is calculated, which is obtained by average pooling the reference node feature vectors (Ref_Node_Vec_kj) of all its historical nodes. Then, the cosine similarity between Overall_State_Vec and each Overall_Ref_Vec_k is calculated to obtain Instance_Sim_k. Based on this similarity, the weights of each reference instance are updated. For example, a soft update mechanism can be used: Cur_Weight_k_new = (1-alpha) multiplied by Cur_Weight_k_old + alpha multiplied by (Instance_Sim_k divided by the sum of similarities of all instances), where alpha is a learning rate parameter. In this way, historical instances that become increasingly similar to the current overall cataloging state will gradually gain more influence, while instances that become irrelevant will gradually lose their weight.

[0160] Step S2100: When the state of the global cataloging candidate state space graph tends to be stable, the standardized cataloging field set and knowledge indexing label corresponding to the final stable state of each node are verified for consistency with the reference instance set, and the difference index between the standardized cataloging field set and knowledge indexing label of each node and the historical standardized cataloging field set and historical knowledge indexing label of its similar reference nodes is calculated.

[0161] After determining that the global state has stabilized in step S156, the final result is not directly output. Instead, an additional round of consistency verification with historical instances is performed. For each node in the tree, such as Node_final, in the final stable state, its final standardized bibliographic field set Std_Metadata_final and final knowledge indexing label set Final_Labels_final have been determined. At this point, its final node semantic feature vector Cur_Semantic_Vec_final (generated from the final state) is again compared with all historical nodes in the historical instance library to find its final set of similar reference nodes (similar to step S250, but based on the final state). Then, the difference index Diff_Score between the node's final result and these final similar reference nodes is calculated. The difference can be a comprehensive index, such as comparing the Jaccard similarity (or difference) of bibliographic field values, comparing the cosine distance of the topic label set, comparing the F1 score difference of the entity label, etc. The above differences are weighted and summed to obtain a quantified difference index Diff_final.

[0162] Step S2110: If the difference index exceeds the preset difference tolerance threshold, the node is marked as a node to be backtracked, and a local backtracking optimization process is triggered for the node to be backtracked. In the local backtracking optimization process, the current state of other nodes is fixed, and only the node to be backtracked is re-executed with the iterative update of the collaborative inference objective function after adding external consistency constraints, until the difference index of the node to be backtracked drops below the difference tolerance threshold.

[0163] Set a tolerance threshold, Thresh_diff. For each node, check its Diff_final. If Diff_final is less than or equal to Thresh_diff, the verification passes. If Diff_final is greater than Thresh_diff, it indicates that the node's final logging result deviates significantly from the most similar historical example, potentially indicating an outlier or error. Mark the node as a "node to be backtracked" and initiate a local backtracking optimization process. In this process, the states of all other nodes in the State_Graph except for this node to be backtracked are fixed to their current final stable state and are no longer changed. Then, for this single node, re-enter the iterative update process similar to steps S154 to S155, but this time the states of adjacent nodes are fixed, and the objective function continues to use F_total_enhanced, which includes external consistency constraints. Perform multiple rounds of iterative sampling on this node until the dissimilarity index Diff_new corresponding to its new stable state drops below Thresh_diff. This local optimization process ensures that even if individual nodes deviate from historical experience during global convergence, they can be corrected in the final stage, so that the final result is consistent with both the global context and a high degree of agreement with credible historical examples.

[0164] Step S2120: Summarize the standardized record fields and knowledge indexing tags of all nodes that have passed the collaborative consistency verification and local backtracking optimization according to the node hierarchy of the hierarchical structure tree of the archive content, and generate the complete record indexing result of the archive file set to be processed.

[0165] All nodes' discrepancy indicators have been verified or optimized through backtracking to meet the standards. At this point, the final state of all nodes constitutes a highly consistent and reliable cataloging and indexing scheme enhanced by historical knowledge. Subsequently, following the detailed process of step S159 and all its sub-steps, the final standardized cataloging field set and knowledge indexing tags are combined with the hierarchical relationship of the archive content hierarchical structure tree (Hierarchy_Tree) and a series of operations are performed, including association encapsulation, file header information generation, serialization assembly, and validity verification. Finally, a complete cataloging and indexing result data package named "Fonds_XXTech_2023_YYYYMMDDHHMMSS_enhanced.json" is generated. This package not only contains detailed cataloging and indexing information of the current batch of archives but also implicitly incorporates the wisdom of historical cataloging practices, further improving its accuracy and consistency. It is output to the specified storage location, and storage path receipt information is generated, marking the successful completion of the entire intelligent cataloging and knowledge indexing process enhanced by historical knowledge.

[0166] In one exemplary embodiment, a multimodal large model-based intelligent cataloging and knowledge indexing system for archival content is provided. This system can be a terminal, server, etc., and its internal structure diagram can be as follows: Figure 2 As shown, this intelligent cataloging and knowledge indexing system for archival content based on a multimodal large model includes a processor, memory, input / output interface, communication interface, display unit, and input device. The processor, memory, and input / output interface are connected via a system bus, and the communication interface, display unit, and input device are also connected to the system bus via the input / output interface. The processor provides computational and control capabilities. The memory includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The input / output interface is used for exchanging information between the processor and external devices. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, mobile cellular networks, near-field communication, or other technologies. When the computer program is executed by the processor, it implements an intelligent cataloging and knowledge indexing method for archival content based on a multimodal large model. The display unit is used to form a visually visible image and can be a display screen, projection device, or virtual reality imaging device. The display screen can be an LCD screen or an e-ink screen. The input device can be a touch layer covering the display screen, or a button, trackball, or touchpad set on the shell of a multimodal big data intelligent recordation and knowledge indexing system, or an external keyboard, touchpad, or mouse.

[0167] It should be noted that, in order to simplify the description of the present invention and thus help to understand one or more embodiments of the invention, multiple features may sometimes be grouped into one embodiment, drawing or description thereof in the foregoing description of the embodiments of the present invention.

Claims

1. A method for intelligent cataloging and knowledge indexing of archival content based on a multimodal large model, characterized in that, The method includes: Obtain a set of archive files to be processed, which includes text archive units, image archive units, and audio archive units with their original storage formats; The set of files to be processed is subjected to cross-modal semantic unified parsing processing, and a first semantic feature vector set of the text file unit, a second semantic feature vector set of the image file unit, and a third semantic feature vector set of the audio file unit are generated based on a preset multimodal large model. Based on the first set of semantic feature vectors, the second set of semantic feature vectors, and the third set of semantic feature vectors, the structure of the archive content is analyzed to generate a hierarchical structure tree of the archive content corresponding to the set of archive files to be processed. The hierarchical structure tree of the archive content includes file-level nodes, case file-level nodes, and in-case metadata nodes. The knowledge base of archival cataloging rules is invoked to perform intelligent matching of cataloging items on the hierarchical structure tree of the archival content, so as to obtain a candidate set of cataloging items to be filled for each node in the hierarchical structure tree of the archival content. Based on the candidate set of the bibliographic entries, cross-node consistency collaborative reasoning is performed to generate the complete bibliographic indexing result of the set of archive files to be processed. The complete bibliographic indexing result includes standardized bibliographic fields and knowledge indexing tags corresponding to each node in the hierarchical structure tree of the archive content.

2. The method for intelligent cataloging and knowledge indexing of archival content based on a multimodal large model according to claim 1, characterized in that, The process of performing cross-modal semantic unified parsing on the set of files to be processed, generating a first semantic feature vector set for the text file units, a second semantic feature vector set for the image file units, and a third semantic feature vector set for the audio file units based on a preset multimodal large model, includes: The original storage format identifier of each file unit in the set of files to be processed is parsed, and the text file unit, the image file unit, and the audio file unit are respectively input to the text input interface, image input interface, and audio input interface of the multimodal large model according to the original storage format identifier; In the text input interface of the multimodal large model, the text file unit is parsed as a character stream and divided into chapter structures to generate a text paragraph sequence with paragraph boundary identifiers, and each text paragraph unit in the text paragraph sequence is mapped to an initial text embedding vector. In the image input interface of the multimodal large model, visual region segmentation and key object detection are performed on the image file unit to generate an image region set containing region location coordinates, and each image region unit in the image region set is mapped to an initial image embedding vector; In the audio input interface of the multimodal large model, acoustic feature extraction and phoneme boundary detection are performed on the audio file unit to generate an audio segment sequence with temporal boundaries, and each audio segment unit in the audio segment sequence is mapped to an initial audio embedding vector. The initial text embedding vector, the initial image embedding vector, and the initial audio embedding vector are input into the cross-modal semantic alignment coding layer of the multimodal large model. The initial text embedding vector, the initial image embedding vector, and the initial audio embedding vector are subjected to modality-independent semantic space mapping through the shared parameter transformation matrix inside the cross-modal semantic alignment coding layer to obtain the text semantic intermediate representation, image semantic intermediate representation, and audio semantic intermediate representation under a unified semantic space. The self-attention mechanism module of the multimodal large model is used to perform cross-modal contextual interaction calculation on the text semantic intermediate representation, the image semantic intermediate representation and the audio semantic intermediate representation to generate a semantically enhanced representation vector that integrates semantic association information between text, image and audio modalities; The semantic enhancement representation vectors are subjected to dimensionality compression and normalization to generate a first set of semantic feature vectors corresponding to the text file unit, a second set of semantic feature vectors corresponding to the image file unit, and a third set of semantic feature vectors corresponding to the audio file unit. Each semantic feature vector in the first set of semantic feature vectors corresponds one-to-one with each text paragraph unit in the text paragraph sequence, each semantic feature vector in the second set of semantic feature vectors corresponds one-to-one with each image region unit in the image region set, and each semantic feature vector in the third set of semantic feature vectors corresponds one-to-one with each audio segment unit in the audio segment sequence.

3. The method for intelligent cataloging and knowledge indexing of archival content based on a multimodal large model according to claim 1, characterized in that, The step of performing archive content structure analysis based on the first semantic feature vector set, the second semantic feature vector set, and the third semantic feature vector set to generate a hierarchical structure tree of archive content corresponding to the set of archive files to be processed includes: The first set of semantic feature vectors is input into a pre-trained archive content hierarchical classifier to perform preliminary determination of the archive hierarchical category to which the text archive unit belongs, and to obtain the candidate hierarchical category probability distribution of the text archive unit. The candidate hierarchical category probability distribution includes the confidence score of the text archive unit belonging to the file-level category, the case file-level category, or the in-case metadata level. Based on the first set of semantic feature vectors and the probability distribution of the candidate hierarchical categories, the text paragraph units that have the function of indicating hierarchical boundaries in the text archive unit are identified, and their corresponding first semantic feature vectors are extracted. The second semantic feature vectors corresponding to the image region units that are associated with the text archive unit in time or space in the second set of semantic feature vectors are combined to perform cross-modal hierarchical boundary verification processing, and the hierarchical attribution result of the archive unit in the archive file set to be processed is generated. Based on the hierarchical attribution determination result of the archive unit, the archive units in the set of archive files to be processed are initially clustered according to their subordinate relationships to obtain an initial hierarchical association set containing parent archive unit identifiers and child archive unit identifiers. The initial hierarchical relationship set is corrected by calling the knowledge base of archival formation rules. Based on the inherent relationship rules between archival formation units, formation time and business activities recorded in the knowledge base of archival formation rules, the hierarchical relationship between parent and child archival units in the initial hierarchical relationship set is adjusted to generate the corrected hierarchical relationship set. The first semantic feature vector, the second semantic feature vector, and the third semantic feature vector corresponding to each archive unit in the modified hierarchical association set are analyzed. The topic semantic summary vector of each archive unit is extracted, and the semantic similarity matrix between different child archive units under the same parent archive unit is calculated based on the topic semantic summary vector. Based on the semantic similarity matrix, the child archive units under the same parent archive unit are serialized and sorted to generate the sequential arrangement information of the child archive units that conforms to the archive formation time logic or business logic. The framework of the hierarchical structure tree of the archive content is constructed by combining the modified hierarchical association set and the sequential arrangement information of the sub-archive units. The framework of the hierarchical structure tree of the archive content is stored in a tree data structure, wherein each node corresponds to an archive unit and records its parent node identifier and child node list. Each node in the hierarchical structure tree of the archive content is assigned a node type identifier. The node type identifier is determined according to the hierarchical classification result of the archive unit and is specifically divided into file-level node identifiers, case file-level node identifiers and in-case metadata node identifiers. The first set of semantic feature vectors, the second set of semantic feature vectors, and the third set of semantic feature vectors are used as node attribute information and are respectively associated and stored in the attribute fields of the corresponding text type nodes, image type nodes, and audio type nodes in the hierarchical structure tree of the archive content, forming a hierarchical structure tree of archive content that includes node hierarchy and node semantic content.

4. The method for intelligent cataloging and knowledge indexing of archival content based on a multimodal large model according to claim 1, characterized in that, The method of calling the archive cataloging rule knowledge base to perform intelligent matching processing on the archive content hierarchical structure tree results in a candidate set of cataloging items for each node in the archive content hierarchical structure tree, including: Traverse each node in the hierarchical structure tree of the archive content, and generate a multidimensional feature description vector for the node based on the node type identifier of the node and the first semantic feature vector, second semantic feature vector or third semantic feature vector associated with the node. The multidimensional feature description vector integrates the semantic content information of the node and its hierarchical position information in the hierarchical structure tree of the archive content. The multidimensional feature description vector of the node is input into the catalog item matching engine of the archive catalog rule knowledge base. The archive catalog rule knowledge base pre-stores a set of catalog item templates corresponding to various archive types and the catalog item field name, catalog item field data type and catalog item field filling constraint rules contained in each catalog item template. In the bibliographic item matching engine, the matching similarity between the multidimensional feature description vector of the node and the template feature vector of each bibliographic item template in the archive bibliographic rule knowledge base is calculated. The template feature vector is pre-generated based on the semantic description of the archive type, forming unit and business scope to which the bibliographic item template is applicable. The bibliographic templates are sorted in descending order based on the matching similarity, and the bibliographic templates with matching similarity exceeding a preset similarity threshold are selected as the candidate bibliographic template set for the node. Each candidate bibliographic item template in the candidate bibliographic item template set is parsed, and the sequence of bibliographic item field names contained in each candidate bibliographic item template and the filling constraint rules corresponding to each bibliographic item field name are extracted. The filling constraint rules include data type constraints, value range constraints and association mapping rules with the semantics of the archive content of the field values. For each field name of a candidate field name in each candidate field name template, according to the filling constraint rules corresponding to the field name, candidate filling content that matches the field name is retrieved from the multidimensional feature description vector of the node and the semantic feature vector of the child or parent node associated with the node in the hierarchical structure tree of the archive content. The candidate values ​​are organized according to their source node identifiers and confidence scores calculated during the retrieval process to generate a candidate value list corresponding to each field name of each bibliographic item under each candidate bibliographic item template. Each candidate value in the candidate value list contains the text of the value and a description of the source path of the text. All candidate bibliographic item templates and their corresponding bibliographic item field names and candidate values ​​are collected to form the bibliographic item filling candidate set of the node. The bibliographic item filling candidate set records multiple possible bibliographic item template selection schemes and multiple possible filling values ​​for each bibliographic item field under each scheme.

5. The method for intelligent cataloging and knowledge indexing of archival content based on a multimodal large model according to claim 1, characterized in that, The process of performing cross-node consistency collaborative reasoning based on the candidate set of bibliographic entries to generate complete file bibliographic indexing result tags for the set of archive files to be processed includes: The candidate set of the bibliographic items of all nodes in the hierarchical structure tree of the archive content is filled and summarized to construct a global bibliographic candidate state space diagram with the hierarchical structure tree of the archive content as the skeleton. Each node in the global bibliographic candidate state space diagram corresponds to a hierarchical structure tree node of the archive content. The state of each node is composed of the currently selected candidate bibliographic item template identifier and the selected filling value of each bibliographic item field. Initialize the state of each node in the global cataloging candidate state space graph, randomly assign a candidate cataloging item template identifier to each node, and randomly select a filling value from the corresponding filling candidate list for each cataloging item field under the candidate cataloging item template to form the initial state of the node; Based on the pre-stored consistency constraints of the cataloging items in the archive cataloging business rule base, a cross-node collaborative reasoning objective function for cataloging items is constructed. The consistency constraints of the cataloging items include the logical consistency constraints of the cataloging item field values ​​among the file-level nodes under the same case file-level node, the uniformity constraints of the same semantic cataloging item field values ​​among different nodes, and the matching constraints of the cataloging item field values ​​and the hierarchical relationship of the archive content hierarchical structure tree. A graph-based collaborative reasoning iterative update process is performed on the global cataloging candidate state space graph. In each iteration, a target node is randomly selected. Based on the cataloging item template identifier and the cataloging item field filling content corresponding to the current state of the target node's adjacent nodes in the archive content hierarchical structure tree, the local conditional probability of the target node selecting different candidate cataloging item templates and different filling content is calculated. The current state of the target node is updated and sampled according to the local conditional probability. The updated state of the target node will replace its original state and affect the calculation of the local conditional probability of other adjacent nodes in subsequent iterations. Repeat the collaborative reasoning iterative update process until the state of all nodes in the global cataloging candidate state space graph tends to be stable. The criterion for determining the stability is that the degree of satisfaction of the cataloging item consistency constraint of the global cataloging candidate state space graph as a whole no longer changes significantly in multiple consecutive iterations. When the state of the global cataloging candidate state space graph tends to be stable, the final selected cataloging item template identifier and the final filled value of each cataloging item field of each node are extracted from the final stable state of each node to form a set of standardized cataloging fields for each node in the hierarchical structure tree of the archive content. Based on the standardized record-keeping field set of each node and the first semantic feature vector, second semantic feature vector or third semantic feature vector of that node, a preset knowledge indexing rule base is invoked to extract and index knowledge units, generating knowledge indexing tags corresponding to the standardized record-keeping fields of the node. The knowledge indexing tags include subject term tags, classification number tags and entity name tags. The standardized record field set and corresponding knowledge indexing tag of each node in the hierarchical structure tree of the archive content are associated and encapsulated to generate the complete record indexing result of the archive file set to be processed. The complete record indexing result is organized with the hierarchical structure tree of the archive content as the organizational framework. Each node in the tree carries its finally determined standardized record field set and knowledge indexing tag.

6. The intelligent cataloging and knowledge indexing method for archival content based on a multimodal large model according to claim 5, characterized in that, The step involves extracting and indexing knowledge units by calling a preset knowledge indexing rule base based on the standardized record-keeping field set of each node and the first, second, or third semantic feature vector of that node, thereby generating knowledge indexing tags corresponding to the standardized record-keeping fields of the node. This includes: The standardized record field set of each node is parsed, and the record field names and corresponding record field values ​​that have the function of indicating entity type are extracted from the standardized record field set. The record field names that have the function of indicating entity type include the name of the responsible person field, the name of the time field, the name of the location field, and the name of the subject field. The names of the recording fields that indicate entity types and the corresponding values ​​of the recording fields are input into the entity recognition rule matcher of the knowledge indexing rule base. The knowledge indexing rule base pre-stores recognition rule templates corresponding to different entity types and their mapping relationship with the dictionary of archival terminology. In the entity recognition rule matcher, candidate entity types are initially determined based on the descriptive field name, and precise or fuzzy matching is performed in the archival domain terminology dictionary in combination with the descriptive field value to generate the entity type determination result and entity standard name of the node. Based on the entity type determination result and entity standard name of the node, and combined with the first semantic feature vector, second semantic feature vector or third semantic feature vector of the node, semantic association retrieval is performed in the topic word table of the knowledge indexing rule base, and the semantic similarity between the semantic feature vector of the node and the topic word vector of each topic word in the topic word table is calculated. Select the topic words whose semantic similarity exceeds the preset topic word similarity threshold as candidate topic word tags for the node, and sort the candidate topic word tags according to the semantic similarity to determine the final topic word tags used for indexing; The standardized record field set of the node is parsed to fill in the record field values ​​related to the subject or business domain involved in the archive content. The classification number mapping table of the knowledge indexing rule base is called to convert the record field values ​​of the subject or business domain into the corresponding archive classification number tags. The entity standard name, the subject term tag, and the archive classification number tag are collected to form a preliminary knowledge indexing tag set for the node; Redundancy and consistency checks are performed on the preliminary knowledge indexing tag set. Tags with semantic repetition or logical conflict are deleted from the preliminary knowledge indexing tag set. Based on the hierarchical relationship between parent and child nodes in the hierarchical structure tree of the archive content, the tags in the preliminary knowledge indexing tag set are processed for hierarchical inheritance and supplementation to generate the final knowledge indexing tags.

7. The intelligent cataloging and knowledge indexing method for archival content based on a multimodal large model according to claim 6, characterized in that, The collection of the entity standard name, the subject term tag, and the archive classification number tag forms the preliminary knowledge indexing tag set for the node, including: Based on the entity type determination result of the node, extract the standard names of personal names, institutional names, place names, and time entities from the standard entity names, and store the standard names of personal names, institutional names, place names, and time entities into the corresponding subsets of personal name tags, institutional tags, place names, and time entities in the preliminary knowledge indexing tag set, respectively. Based on the semantic similarity ranking results between the semantic feature vector of the node and the topic word vector of each topic word in the topic word table, the top-ranked topic words are selected as preferred topic word tags, and the preferred topic word tags and their word family relationship information in the topic word table are stored in the topic word tag subset of the preliminary knowledge indexing tag set. The word family relationship information includes the hypernyms, hyponyms and related words of the preferred topic word tags. The hierarchical structure of the archive classification number tags is parsed, the classification category identifier, classification sub-category identifier, and classification detail identifier corresponding to the archive classification number tags are extracted, and the classification category identifier, the classification sub-category identifier, and the classification detail identifier are organized according to the hierarchical relationship and stored in the classification number tag subset of the preliminary knowledge indexing tag set; Based on the node type identifier of the node and the depth information of the node in the hierarchical structure tree of the archive content, the indexing depth level of the node in the knowledge indexing system is determined, and the indexing depth level is added as a metadata tag to the preliminary knowledge indexing tag set; Combining the title citation field values ​​and abstract citation field values ​​in the standardized citation field set of the node, core keywords are extracted from the title citation field values ​​and abstract citation field values. The core keywords are then semantically matched with the preferred subject term tags. The successfully matched core keywords are added as supplementary subject term tags to the subject term tag subset. All subsets of person name entity tags, organization entity tags, place name entity tags, time entity tags, subject term tags, and classification number tags in the preliminary knowledge indexing tag set are formatted and encapsulated to generate a preliminary knowledge indexing tag set data structure with internal structured organization.

8. The method for intelligent cataloging and knowledge indexing of archival content based on a multimodal large model according to claim 5, characterized in that, The step of associating and encapsulating the standardized record-keeping field set and corresponding knowledge indexing tags of each node in the hierarchical structure tree of the archive content to generate the complete record-keeping indexing result of the archive file set to be processed includes: For each node in the hierarchical structure tree of the archive content, a bibliographic indexing record unit is created. The bibliographic indexing record unit includes a node identifier field, a node type identifier field, a standardized bibliographic field set storage area, and a knowledge indexing tag storage area. The standardized record field set of each node is stored in the standardized record field set storage area of ​​the record indexing record unit in the form of key-value pairs of record field name and record field value, and the source path description information of each record field value in the record field filling candidate set is retained as source traceability metadata. The knowledge indexing tags of each node are classified and stored in the knowledge indexing tag storage area of ​​the recording unit according to the tag type. The knowledge indexing tag storage area is divided into an entity tag storage sub-area, a subject term tag storage sub-area, and a classification number tag storage sub-area. The rule identifier or model version information on which the knowledge indexing tag was generated is associated with each knowledge indexing tag. Establish pointer links between the recording indexing record units of parent nodes and child nodes in the hierarchical structure tree of the archive content, so that the recording indexing record unit of any node can access the recording indexing record units of its parent node and all its child nodes through the pointer links. Based on the original storage path and archival group number information of the set of archives to be processed, the file header identification information of the complete archival cataloging result is generated. The file header identification information includes the archival group number identifier, the archival catalog number identifier, and the archival formation time range descriptor. The file header identification information and the cataloging and indexing record units of all nodes are serialized and assembled to generate a complete archive cataloging and indexing result data packet with a self-describing structure. The data format of the complete archive cataloging and indexing result data packet is compatible with the data exchange standard of the archive management system. The complete archival cataloging result data package is digitally signed to generate a digital digest value used to verify the authenticity of the source and the integrity of the content of the complete archival cataloging result data package, and the digital digest value is associated with and stored with the complete archival cataloging result data package.

9. A system for intelligent cataloging and knowledge indexing of archival content based on a multimodal large model, characterized in that, include: processor; A machine-readable storage medium for storing machine-executable instructions of the processor; The processor is configured to execute the intelligent cataloging and knowledge indexing method for archive content based on a multimodal large model as described in any one of claims 1 to 8 by executing the machine-executable instructions.

10. A computer program product, characterized in that, The computer program product includes machine-executable instructions stored in a computer-readable storage medium. The processor of the intelligent archival content cataloging and knowledge indexing system based on a multimodal large model reads the machine-executable instructions from the computer-readable storage medium and executes the machine-executable instructions, causing the intelligent archival content cataloging and knowledge indexing system based on a multimodal large model to perform the intelligent archival content cataloging and knowledge indexing method based on a multimodal large model as described in any one of claims 1 to 8.

Images