A patent drawing intelligent indexing method and system

Abstract

The present invention discloses a patent drawing intelligent indexing method and system, the method comprising: extracting a pair of figure marks from the patent figure mark description of the patent specification; extracting component names from the patent text using a named entity recognition (NER) model; matching the figure marks and constructing a pair of figure marks using a Lion series algorithm; fusing the extracted figure mark pairs with the figure mark links of the patent drawings and displaying the component names at designated locations; linking the component names in the patent specification to the relevant drawings and figure marks. The problem of considering the number of words when extracting component names is avoided, and the method is suitable for extracting component names of compound word types, and in terms of performance, the method achieves the effect of combining the excellent performance of rules with the generalization ability of models. The method improves efficiency while enhancing the user reading experience.

Description

Technical Field

[0001] The present invention relates to the technical field of document recognition and processing, and in particular to a method and system for intelligent indexing of patent drawings. Background Art

[0002] The Patent Examination Guidelines stipulate that "drawing numerals shall be numbered using Arabic numerals." When understanding the technical solution through the drawings in the patent specification, readers are also required to use Arabic numerals to compare the text and extract the component names in the drawings. When patent applications contain a large amount of content, it is inconvenient to check whether the drawing numerals and the corresponding component names are correct. Comparing the specification text with the drawing numerals is time-consuming and laborious, resulting in inefficient review and a high risk of errors.

[0003] In the Chinese patent document entitled "A Method and System for Generating Intelligent Patent Figures," with publication number CN116168411A, the method identifies the figure marks in the figure document, the characteristic marks and characteristic nouns in the specification document, and obtains the correspondence between the characteristic marks and characteristic nouns. By matching the figure marks in the figure document with the characteristic marks in the specification, the figure marks in the figure document can be mapped to the characteristic nouns in the specification document, and the characteristic nouns expressed by the figure marks can be displayed in the figure document. This method clearly displays the meaning expressed by the figure marks, improving the reviewer's reading experience.

[0004] This patent application solution extracts characteristic markers and characteristic nouns and establishes a matching relationship between the characteristic markers and characteristic nouns. In the patent application specification document, there may be different characteristic markers corresponding to the same characteristic noun due to writing errors, or different characteristic nouns corresponding to the same characteristic marker. In the preset segment set of the specification, the number of occurrences of different phrase types in phrase pairs with the same local phrases is obtained. By using the phrase pairs with the most occurrences, the problem of having too many local phrase pairs due to writing errors is eliminated with a high probability, thereby improving the matching accuracy of phrase pairs. However, it also ignores the actual situation that there is a one-to-many mapping relationship between characteristic nouns and characteristic markers.

[0005] In the patent document entitled "Patent Figure Mark Description Output Method and Device and System Therefor" and with publication number CN115427944A, a patent figure mark recognition method is proposed. Based on text mining technology, a figure mark description extraction rule is established using multiple patent specification samples, and a method for extracting figure mark descriptions in patent specifications based on the established figure mark description extraction rule is proposed. The figure mark description refers to the entity represented by the text such as the component name located in the specification or claim corresponding to the figure mark. The rule extraction step includes: (1) classifying the multiple patent specification samples according to the application country; (2) extracting common features according to the classified application country; (3) establishing the figure mark description extraction rule based on the extracted features. For example, in the case of South Korea, the feature that the figure mark description is located before the figure mark, the feature that the figure mark is contained in two brackets, etc. can be extracted as a common feature. In the case of the United States, the feature that the figure mark description is located before the figure mark, the feature that the figure mark is written in bold, and the feature that the figure mark is not distinguished by two brackets like in South Korea can be extracted as a common feature. Depending on the country of application, patent specifications may contain a separate "symbol description" category that includes reference symbols and their descriptions. This can also be extracted as a common feature, and the "symbol description" category can be used for subsequent extraction of reference symbol descriptions. By studying various patent specification samples, various common features can be extracted by country of application. Based on these extracted common features, a rule (or model) for extracting reference symbol descriptions is established and used to extract reference symbol descriptions from patent specifications. An embodiment is proposed in which, when multiple reference symbol descriptions are extracted, the patent specification is searched for the extracted reference symbol descriptions and the reference symbol description with the largest number of search results is determined as the final reference symbol description for extraction. The proposed embodiment limits the number of words in the reference symbol description to a preset number based on the accumulated reference symbol description data. Specifically, the number of words in all compound words in the reference symbol description database is counted, and the number of words with a statistically low extraction rate / probability is set as the limit. If the probability of a compound word with five or more words being extracted as a reference symbol description is 0.0001%, a maximum of four words are used as the reference symbol description.

[0006] The disclosed patent figure mark recognition method is completely based on rules to realize the extraction of figure mark descriptions, and lacks the generalization ability of model-based extraction methods. In addition, the method proposed by the patent to extract multiple figure mark descriptions for a mark and determine the figure mark description with the largest search volume as the final figure mark description is not necessarily suitable for actual scenarios, because there is a one-to-many mapping relationship between figure marks and mark descriptions in some patents, which is inconsistent with the actual situation. For example, "Fluid-fillable bladder system, welding tool and method for operating welding tool" (Chinese patent publication with publication number CN112622722B) is attached. Figure 1 The number 9 in the patent text has a one-to-many mapping relationship between "opening 9" and "air supply system 9." Another example is the description "Metal sheet strip heat treatment and drying device" (Chinese patent publication number CN111947428B), which contains the phrases "metal sheet strip 3" and "metal sheet strip plate 3." The number 3 corresponds to two component names: "metal sheet strip" and "metal sheet strip plate." The proposed method limits the number of words in a figure mark description to a preset number based on the accumulated figure mark description data. This involves counting the number of words in all compound words in the figure mark description database, setting the number of words with a statistically low extraction rate / probability as a limit, and using a maximum of four words as figure mark descriptions. A statistically calculated threshold is then applied based on the distribution of the accumulated database, discarding figure mark descriptions longer than five words. Extracting figure mark descriptions is limited to the number of characters to the left of the number. Research is still needed on more accurate and efficient methods for extracting compound word-type mark descriptions. Summary of the Invention

[0007] In view of this, the present invention provides a method and system for intelligent indexing of patent drawings, which improves review efficiency while enhancing user reading experience.

[0008] In order to achieve the above object, the present invention provides the following technical solutions:

[0009] In one aspect, the present invention provides a method for intelligently indexing patent drawings, comprising:

[0010] Step A1, extracting reference numeral pairs from the patent reference numeral description in the patent specification;

[0011] Step B1: extract component names from patent text using named entity recognition (NER) model;

[0012] Step B2, using the Lion series algorithm to match reference numerals and construct reference numeral pairs;

[0013] Step C: Fusing the reference sign pairs extracted by the named entity recognition (NER) model in step B2 with the reference sign pairs extracted by the rules in step A1;

[0014] Step D: Link the reference numerals of the patent drawings and display the component names at designated locations;

[0015] Step E: Link the component names in the patent specification to the relevant drawings and figure marks.

[0016] More preferably, step A1 extracts the reference numeral pairs from the patent reference numeral description in the patent specification by the following steps:

[0017] Step A11, sorting the punctuation marks for segmentation, constructing a list of segmentation punctuation marks, and constructing a list of component names and their reference numeral separators;

[0018] Step A12: Use the separator punctuation mark list separator_lst to segment and obtain a character string list of component names and their reference numerals.

[0019] Step A13: Use the interval symbol list interval_lst of the component name and its reference numeral to obtain the component name and reference numeral.

[0020] More preferably, when the component name and its reference numeral cannot be obtained by segmentation in step A12, the prefix and suffix reference numerals are obtained by filtering the prefix and suffix reference numerals using a regular expression.

[0021] Among them, the NER model includes: NER model architecture, NER model training, and NER model application.

[0022] The NER model architecture includes: a large model vectorization layer, a bidirectional long-short term neural network layer, and a label sequence prediction layer;

[0023] The data set used for the NER model training is in a predetermined format;

[0024] The NER model is trained and the component names are predicted using the NER model.

[0025] Among them, the Lion King series of algorithms include the Lion King Territory Inspection Algorithm, the Lion King Enclosure Algorithm and the Lion King Election Algorithm.

[0026] Preferably, step D specifically includes:

[0027] Input the dictionary marks_num2ch and drawings that map the reference marks to the component names, and output the drawings containing the component names, so as to realize the function of linking the reference marks of the patent drawings and displaying the component names at the specified positions.

[0028] More preferably, the component names in the patent specification are linked to the relevant drawings and figure numbers by the following steps:

[0029] Input component names, a dictionary mapping component names to reference numerals, all drawings and their reference numeral information, wherein the reference numeral information includes the reference numeral and its position;

[0030] Output the component name with special effects, the associated drawings, and the drawing marks and component names in the drawings.

[0031] Another aspect of the present invention provides a patent drawing intelligent indexing system, comprising:

[0032] A first extraction module is used to extract the reference numeral pairs in the reference numeral description of the patent specification;

[0033] The second extraction module uses the NER model to extract component names;

[0034] The construction module uses the Lion series algorithm to match the reference marks and construct the mark pairs;

[0035] a fusion module, fusing the reference sign pairs extracted by the first extraction module with the reference sign pairs extracted by the second extraction module;

[0036] A display module, used to link reference numerals and display component names at designated locations;

[0037] A linking module is used to link the component names in the patent specification to the relevant drawings and figure marking modules.

[0038] The present invention has the following advantages:

[0039] The invention of this application provides a patent intelligent figure citation method and system, which realizes the linking of figure marks of patent figures and displays the component names and the component names of the patent specification at designated locations to link related figures and component information; the technical solution of the invention of this application improves the examination efficiency while enhancing the user reading experience.

[0040] The entity type of the NER model in the present invention has a simple training data set construction process and low labeling cost.

[0041] The invention of this application proposes a patented component name recognition method, which realizes component name extraction based on rules combined with a denoising model and a named entity extraction model. Instead of performing word segmentation, the component name is extracted based on a string design algorithm or a model, avoiding the problem of considering the number of words in component name extraction. It is suitable for the extraction of compound word type component names, and in terms of performance, it achieves the effect of combining the excellent performance of rules with the generalization ability of the model.

[0042] The patented intelligent figure indexing method and system described in this application supports a one-to-many mapping relationship between legal figure marks and component names. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] To more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for the embodiments or the description of the prior art. Obviously, the drawings described below are merely illustrative, and those skilled in the art can derive other implementation drawings based on the provided drawings without inventive effort.

[0044] The structures, proportions, sizes, etc. illustrated in this specification are intended solely to complement the contents disclosed herein and to facilitate understanding and reading by persons skilled in the art. They are not intended to limit the conditions under which the present invention may be implemented and therefore have no substantive technical significance. Any structural modifications, changes in proportions, or adjustments in sizes, without affecting the efficacy and objectives of the present invention, shall remain within the scope of the technical contents disclosed herein.

[0045] Figure 1 A flow chart of a method for intelligently indexing patent drawings provided in accordance with an embodiment of the present invention;

[0046] Figure 2 Schematic diagram of the NER model architecture provided in an embodiment of the present invention;

[0047] Figure 3 Patent reference numerals provided in the embodiments of the present invention are linked and display the component names in designated locations as flow charts;

[0048] Figure 4 Patent specification component names provided in the embodiments of the present invention are linked to the accompanying flowchart;

[0049] Figure 5 Schematic diagram of the intelligent indexing system for patent drawings provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0050] The following describes the implementation of the present invention using specific embodiments. Those skilled in the art will readily understand the other advantages and benefits of the present invention from the disclosure herein. Obviously, the embodiments described are only a portion of the present invention, not all of it. All other embodiments derived by persons of ordinary skill in the art based on the embodiments of the present invention without inventive effort are intended to fall within the scope of protection of the present invention.

[0051] This application proposes a method for intelligent indexing of patent drawings, involving the following concepts:

[0052] (1) Component name: the name expressed in words and text corresponding to the figure mark in the patent specification.

[0053] (2) Reference numeral pair: a pair of bidirectional mapping relationships between reference numerals and component names.

[0054] (3) Intelligent Figure Reference: Based on the reference numerals, component names, and reference numeral pairs, the following two functions are realized:

[0055] <1> Reference numerals are linked and component names are displayed at designated locations;

[0056] <2> The names of the components in the patent specification are linked to the relevant drawings and figure numbers.

[0057] Example 1

[0058] Reference Figure 1 , an embodiment of the present invention provides a method for intelligently indexing patent drawings, comprising:

[0059] Step A1, extracting reference numeral pairs from the patent reference numeral description in the patent specification;

[0060] Step B1: extract component names from patent text using named entity recognition (NER) model;

[0061] Step B2, using the Lion series algorithm to match reference numerals and construct reference numeral pairs;

[0062] Step C: fusing the reference sign pairs extracted by the named entity recognition (NER) model in step B2 with the reference sign pairs extracted in step A1;

[0063] Step D, linking the reference numerals and displaying the component names at designated locations;

[0064] Step E: Link the component names in the patent specification to the relevant drawings and figure marks.

[0065] The following describes each step in detail:

[0066] Step A1, extracting reference numeral pairs from the reference numeral descriptions in the patent specification;

[0067] This feature module inputs the patent figure mark description and outputs the figure mark pair, realizing the function of extracting the figure mark pair from the patent text figure mark description, including the following steps:

[0068] Step A11: Arrange the punctuation marks for segmentation and build a list of segmentation punctuation marks:

[0069] separator_lst=[', ', '. ', '? ', ';', '! ', '!', '\ '],

[0070] Build a list of component names and their reference number separators:

[0071] interval_lst = [', ', '-', '—', '——', ':', ':', ' ', '\t'];

[0072] Step A12: Use the separator punctuation mark list separator_lst to obtain a character string list of component names and their reference numerals.

[0073] Step A13: Use the interval symbol list interval_lst for the component name and its reference number to obtain the component name and reference number. If the component name and reference number cannot be obtained by segmentation in step A12, the prefix and suffix reference numbers can be obtained by filtering them using regular expressions, as described in "Algorithm 1: Regular Expression Matching Prefix and Suffix to Extract Reference Numbers and Component Names."

[0074] Algorithm 1: Regular expression matching prefix and suffix to extract reference symbols and component names

[0075] Input: The character string consisting of the component name and reference numeral output in step A12.

[0076] Output: Segmented component names and their reference numbers.

[0077] Perform the following steps:

[0078] S101: define a component name list ch_lst = [], define a reference numeral list num_lst = []

[0079] S102: Regularly try to get the reference mark from the tail, the pseudo code is as follows:

[0080] sub_num_lst = re.findall(r'[(((]*[\da-zA-Z-—~~.%%+_=* / ^]+[))]*$',sub_mark),

[0081] Among them, sub_num_lst is used to receive the reference mark extraction result of re.findall(), which is a list structure type; re.findall() is a regular method used to find all reference marks that meet the regular expression; sub_mark is a string consisting of the component name and the reference mark.

[0082] S103: If the reference mark is not obtained in S102, try to obtain it from the header. The pseudo code is as follows:

[0083] sub_num_lst = re.findall(r'^[((]*[\da-zA-Z-—~~.%%+_=* / ^]+[))]*',sub_mark),

[0084] Among them, sub_num_lst is used to receive the drawing reference extraction result of re.findall(), and its structure type is a list; re.findall() is a method of regular expressions, used to find all drawing references that meet the regular expression; sub_mark is a string composed of part names and drawing references.

[0085] S104: Regularly extract part names. The pseudo-code is as follows:

[0086] sub_ch_lst = re.findall(r'((第(一|二|三|四|五|六|七|八|九|十|\d)+)*[a-zA-Z]*[\u4e00-\u9fa5]+)', sub_mark),

[0087] Among them, sub_ch_lst is used to receive the part name extraction result of re.findall(), and its structure type is a list; re.findall() is a method of regular expressions, used to find all part names that meet the regular expression; sub_mark is a string composed of part names and drawing references.

[0088] S105: Verify that the part name and drawing reference are not empty, and verify the consistency of the number of part names and drawing references.

[0089] S106: Return the part name list ch_lst and the drawing reference list num_lst.

[0090] Step B1: Use the NER model to extract part names from the patent text;

[0091] This feature module inputs the patent specification text and outputs part names, implementing the function of extracting part names from the patent text using the NER model. The NER model includes: NER model architecture, NER model training, and NER model application.

[0092] <1>NER model architecture

[0093] Such as Figure 2 The NER model architecture shown includes: a large model vectorization layer, a bidirectional long short-term neural network layer, and a label sequence prediction layer.

[0094] The large model vectorization layer uses the pre-trained language model ERNIE (Enhanced Language Representation with Informative Entities) to vectorize the input text data and calls the transformer's AutoModel.from_pretrained(ernie_config) method to load it. The parameter ernie_config represents the model configuration class.

[0095] A bidirectional long-short-term neural network layer uses a bidirectional recurrent neural network for feature extraction and encoding. It is implemented by calling torch.nn.LSTM (embedding_dim, hidden_dim, num_layers=rnn_layers, bidirectional= True, dropout=dropout_ratio, batch_first=True). The embedding_dim parameter represents the embedding vector dimension; the hidden_dim parameter represents the hidden layer dimension; the num_layers=rnn_layers parameter represents the number of recurrent neural network layers; the bidirectional=True parameter represents bidirectional; the dropout=dropout_ratio parameter represents the random dropout rate; and batch_first=True represents the batch size in the first dimension of the tensor.

[0096] The label sequence prediction layer is encoded through conditional random fields, and then the Viterbi algorithm is used to obtain the set of labels with the highest probability as the output of the algorithm. It is implemented by calling torchcrf.CRF(num_tags=tagset_size, batch_first=True). The parameter num_tags=tagset_size specifies the number of labels, and the parameter batch_first=True indicates that the batch size is placed in the first dimension of the tensor.

[0097] <2> NER model training

[0098] The entity tags of the NER model are defined as shown in Table 1 Entity tags of the NER model.

[0099] Table 1 Entity labels of NER model

[0100]

[0101] The dataset format used for the NER model training is shown in Table 2.

[0102] Table 2. Examples of NER model training datasets

[0103]

[0104] The NER model training is shown in the following "Algorithm 2 Patent NER Model Training".

[0105] Algorithm 2 Patented NER model training

[0106] Input: Dataset used for NER model training

[0107] Output: trained NER model

[0108] Perform the following steps:

[0109] S201: Read in the data set and divide it into training set, validation set and test set.

[0110] S202: Implement the model and initialize it, which mainly includes: loading ERNIE and initializing model parameters. The pseudo code for loading ERNIE is as follows:

[0111] AutoModel.from_pretrained(ernie_config),

[0112] The parameter ernie_config represents the model configuration class, which is used to define model configuration information, including: dataset location, maximum input sequence length, batch size, embedding vector dimension, recurrent neural network hidden layer dimension, random inactivation rate, learning rate, early stopping trigger step number, and optimizer specification; call the AutoModel.from_pretrained() method of transformers to load the model and initialize it.

[0113] Initialize the model parameters, mainly including: bidirectional long-term short-term neural network layer, label sequence prediction layer. The pseudo code for the bidirectional long-term short-term neural network layer is as follows:

[0114] nn.LSTM (embedding_dim, hidden_dim, num_layers

[0115] = rnn_layers, bidirectional

[0116] = True, dropout

[0117] =dropout_ratio, batch_first=True),

[0118] The embedding_dim parameter specifies the embedding vector dimension; the hidden_dim parameter specifies the hidden layer dimension; the num_layers parameter specifies the number of recurrent neural network layers; the bidirectional parameter specifies bidirectionality; the dropout parameter specifies the dropout ratio; and batch_first specifies the batch size in the first dimension of the tensor. Call the nn.LSTM() method to define a bidirectional long-short-term neural network layer.

[0119] The pseudo code for the label sequence prediction layer is as follows:

[0120] CRF(num_tags=tagset_size, batch_first=True)

[0121] Among them, num_tags=tagset_size specifies the number of tag types; batch_first=True specifies the batch size dimension priority; CRF() defines the conditional random field for tag sequence prediction.

[0122] S203: Specifies to use the Adam optimization algorithm to define the optimizer.

[0123] S204: Set the model training hyperparameters batch_size=8, epochs=5.

[0124] S205: Iterative optimization model model:

[0125] S2051: Gradient clearing, pseudo code: model.zero_grad().

[0126] S2052: Calculate the loss, based on the negative log-likelihood function definition formula as follows:

[0127] (1)

[0128] in, represents the loss function that needs to be minimized to optimize the model parameters; λ represents the parameter vector, which needs to be learned through the training process; N represents the number of training samples; T gives the length of the sample sequence (in time steps); Represents the kth feature function, whose input is two adjacent labels y t-1 and y t , the entire observation sequence x and the current time step t, the feature function is used to capture the relationship between the label and the observation value; k represents the weight of the kth feature function; represents the label of the i-th training sample at time step t-1; represents the label of the i-th training sample at time step t; represents the observation sequence of the i-th training sample; t represents the time step; Represents the logarithmic partition function, used for normalization, partition function Represents the probability sum of all possible label sequences of the i-th sample, which is used to ensure the legitimacy of the probability distribution (the sum of the probabilities is 1).

[0129] S2053: Gradient backpropagation, pseudocode: loss.backward().

[0130] S2054: Gradient update: Pseudocode: optimizer.step().

[0131] S206: Return the trained model.

[0132] <3> NER model application

[0133] Apply the NER model to predict component names, as shown in "Algorithm 3: Applying the NER model to predict component names."

[0134] Algorithm 3: Apply NER model to predict component names

[0135] Input: data to be predicted

[0136] Output: List of component names

[0137] Perform the following steps:

[0138] S301: Process and load the data to be predicted sent.

[0139] S302: Input the loaded data sent into the model.

[0140] S303: The model predicts the output label sequence labels.

[0141] S304: Collect component names:

[0142] S3041: Define a list ne_lst=[] for storing component names, and define an iteration index variable idx=0.

[0143] S3042: Iterate label sequence labels:

[0144] S30421: Get the current label lb=labels[idx].

[0145] S30422: Define label mapping dictionary: implement the function of mapping the current label to the corresponding processing method.

[0146] S30423: If the current tag is a legal tag, call the corresponding processing method mapped to the current tag and add the returned non-empty component name to the list ne_lst; otherwise, increase the iteration index variable idx by 1.

[0147] S305: Return the component name list ne_lst.

[0148] Step B2, designing a Lion King series algorithm to match reference numerals and construct reference numeral pairs;

[0149] This feature module inputs a list of component names and patent specification text, and outputs a pair of figure mark pairs, realizing the function of matching figure marks from the patent specification and constructing mark pairs, involving the Lion King Territory Inspection Algorithm, the Lion King Enclosure Algorithm and the Lion King Election Algorithm.

[0150] Algorithm 4 Lion King Territory Inspection Algorithm

[0151] Input: component name list ne_lst and patent specification all_content.

[0152] Output: Reference mark pairs, i.e. reference marks mapped to component name dictionary marks_num2ch and component names mapped to reference mark dictionary marks_ch2num.

[0153] step:

[0154] S401: Identify the scent of a lion group and define the regular expression of the reference numerals:

[0155] re_num_suffix = r'[^\u4e00-\u9fa5,:;. ! ? ;:\ ]+'

[0156] S402: Define and store a dictionary of mapping reference marks to component names, marks_num2ch, and define and store a dictionary of mapping component names to reference marks, marks_ch2num.

[0157] S403: Ranking the Lion King's force value, sorting the component name list in reverse order based on length:

[0158] all_ne_lst = sorted(ne_lst, key=lambda ne: len(ne), reverse=True),

[0159] Among them, ne_lst is the input component name list; key=lambda ne: len(ne) specifies sorting by component name length; reverse=True specifies sorting in reverse order of component name length, that is, sorting from long to short.

[0160] S404: Traverse the component name list and construct reference numeral pairs:

[0161] S4041: Identify the scent of the current lion king and lion group, and construct a regular expression matching the current component name and its reference symbol:

[0162] re_part_num = ne.replace('+', '\+') + re_num_suffix,

[0163] re_part_num_ext = re_num_suffix + '[::.]{0,}' + ne.replace('+', '\+'),

[0164] Where re_part_num is a suffix reference symbol matching regular expression; re_partnum_ext is a prefix reference symbol matching regular expression.

[0165] S4042: Set the need_prefix_process flag to True to check whether prefix reference mark processing is required, and implement suffix reference mark matching processing:

[0166] part_num_res_suffix_lst = re.findall(re_part_num, all_content),

[0167] Among them, part_num_res_suffix_lst stores a list of matching results of part names and their suffix reference symbols.

[0168] S4043: Traverse the list of matching results of the component name and its suffix reference number part_num_res_suffix_lst:

[0169] S40431: The current Lion King circles the land for the first time, passes the current component name and its suffix reference mark string as parameters, calls "Algorithm 5 Lion King Circle Algorithm", updates the reference mark mapping to the component name dictionary marks_num2ch and the component name mapping to the reference mark dictionary marks_ch2num, and returns the suffix processing success flag suffix_process_flag.

[0170] S40432: If the suffix processing success flag suffix_process_flag = True, modify the prefix reference numeral processing need flag need_prefix_process = False.

[0171] S4044: If the need prefix reference mark processing flag need_prefix_process=True, then:

[0172] S40441: Execute prefix figure mark processing.

[0173] S40442: Traverse the part name and its prefix reference number matching result list part_num_res_prefix_lst:

[0174] S404421: The current Lion King circles the land for the second time, passing the current component name and its prefix reference mark string as parameters, calling "Algorithm 5 Lion King Circle Algorithm", updating the reference mark mapping to the component name dictionary marks_num2ch and the component name mapping to the reference mark dictionary marks_ch2num.

[0175] S405: Return reference mark pairs: that is, reference marks are mapped to component name dictionary marks_num2ch and component names are mapped to reference mark dictionary marks_ch2num.

[0176] Algorithm 5 Lion King Enclosure Algorithm

[0177] Input: the reference mark to be updated is mapped to the component name dictionary marks_num2ch and the component name is mapped to the reference mark dictionary marks_ch2num, the string part_num_res that matches the component name and its prefix and suffix reference marks, and the component name ne.

[0178] Output: The updated reference mark is mapped to the component name dictionary marks_num2ch and the component name is mapped to the reference mark dictionary marks_ch2num, and the component name and its prefix and suffix reference marks are processed successfully.

[0179] Perform the following steps:

[0180] S501: The lion king obtains the nearby odor and extracts the substring of the reference mark:

[0181] curr_num_str = part_num_res.replace(ne, ''),

[0182] Among them, curr_num_str represents the total odor information of the vicinity; part_num_res is the character string matched by the component name and its prefix and suffix reference symbols; ne is the component name.

[0183] S502: Set the tag pair successful matching flag and initialize it to False:

[0184] FIND_NUM=False;

[0185] S503: Odor decomposition and segmentation to obtain a list of reference numerals:

[0186] curr_num_lst = re.split(r'[, / ]+', curr_num_str),

[0187] Here, curr_num_lst is a list consisting of the segmented reference numerals.

[0188] S504: traverse the location of each smell, that is, the reference number list curr_num_lst:

[0189] S5041: Clean the current reference numeral curr_num and remove illegal prefixes and suffixes of the reference numeral.

[0190] S5042: Determine whether the reference mark is illegal. If illegal, proceed to the next reference mark processing.

[0191] S5043: Update the reference mark mapping to the component name dictionary marks_num2ch:

[0192] S50431: Get the existing lion list and extract the component name list of the current reference mark from marks_num2ch:

[0193] tmp_part_lst = marks_num2ch.get(curr_num, []),

[0194] Among them, tmp_part_lst is the existing component name list of the current figure mark taken from marks_num2ch.

[0195] S50432: After adding the current lion king to the existing lion king list, call "Algorithm 6 Lion King Election Algorithm" to conduct the lion king election, and obtain the eliminated lion king list to_be_deleted and the winning lion king list win_part_lst.

[0196] S50433: Update dictionary marks_num2ch:

[0197] marks_num2ch[curr_num] = win_part_lst;

[0198] S5044: Update the mapping of component names to the reference mark dictionary marks_ch2num:

[0199] S50441: Get the existing reference mark list and extract the reference mark list of the current component name from marks_ch2num:

[0200] tmp_num_lst = marks_ch2num.get(ne, []),

[0201] Among them, tmp_num_lst is a list of existing reference marks of the component name ne taken from marks_ch2num.

[0202] S50442: Add the current reference mark curr_num to the existing reference mark list tmp_num_lst, and then update the dictionary marks_ch2num:

[0203] marks_ch2num[ne] = tmp_num_lst;

[0204] S5045: Check and process the consistency of the two dictionaries marks_num2ch and marks_ch2num.

[0205] S5046: If the current reference mark contains a number, it is a successful reference mark, and the component name and its prefix and suffix reference mark processing success flag FIND_NUM is modified to True.

[0206] S505: Return the component name and its prefix and suffix reference numbers, indicating a successful processing, FIND_NUM.

[0207] Algorithm 6 Lion King Election Algorithm

[0208] Input: The lion king to be elected, that is, the component name list ne_lst.

[0209] Output: the eliminated lion king, that is, the list of removed component names to_be_deleted, and the winning lion king, that is, the list of retained component names win_part_lst.

[0210] Perform the following steps:

[0211] S601: Sort the lion king list ne_lst from short to long according to length.

[0212] S602: Define and initialize the eliminated lion king list to_be_deleted=[].

[0213] S603: Start outer iteration, traverse the lion king list ne_lst:

[0214] S6031: If there is no more than one lion in the lion list ne_lst, then jump out of S603 and execute S604.

[0215] S6032: Otherwise, start inner iteration and traverse all lion kings behind the current lion king:

[0216] S60321: If the length of the current outer iteration lion is equal to the current inner iteration lion, continue the inner iteration to process the next lion.

[0217] S60322: If the current outer iteration lion is not a substring of all the subsequent lions. Then, the current lion is added to the winning lion list win_part_lst. Otherwise, execute step S603221:

[0218] S603221: If there is a lion after the current outer iterative lion whose length satisfies formula 2, the current outer iterative lion is added to the eliminated lion list to_be_deleted.

[0219] (2)

[0220] in, is the length of any Lion component name that follows; The length of the current Lion component name; Indicates a value between 1 and 1.5 times the length of the Lion component name.

[0221] S603222: Otherwise, the current outer layer lion king is added to the winning lion king list win_part_lst.

[0222] S604: Return the eliminated lion king list to_be_deleted and the winning lion king list win_part_lst.

[0223] Step D: Link the reference numerals of the patent drawings and display the component names at designated locations;

[0224] This feature module takes as input a dictionary (marks_num2ch) that maps reference marks to component names, and a drawing. It outputs the drawing with the component name. This allows the patent drawing to be linked to the reference marks and display the component name at the specified location.

[0225] Taking the implementation effect of the drawings and component names of the Chinese patent document with publication number CN108266268A as an example, Figure 3 Link the patent figure mark and display the component name flow chart at the designated location, such as Figure 3 As shown, the implementation process is given, involving the connection of reference numerals and the algorithm of component names.

[0226] Algorithm 7 Algorithm for connecting reference numerals and displaying component names

[0227] Input: a dictionary mapping reference marks to component names, marks_num2ch, and a drawing.

[0228] Output: Drawing with component names.

[0229] Perform the following steps:

[0230] S701: Optical Character Recognition: Use OCR (Optical Character Recognition) software, such as PaddleOCR, to identify the reference mark information in the drawings. The reference mark information includes the reference mark and its position. The reference mark is stored in the list num_lst in the following format:

[0231] [num1, …],

[0232] Wherein, num1 represents a specific figure mark.

[0233] The reference numbers and their positions are stored in the dictionary list num_loc_lst in the following format:

[0234] [{num1: [[x1, y1],[x2, y2],[x3, y3],[x4, y4]]}, …],

[0235] Among them, num1 represents a specific figure mark; [x1, y1] represents the horizontal and vertical coordinates of the upper left corner of the figure mark; [x2, y2] represents the horizontal and vertical coordinates of the upper right corner of the figure mark; [x3, y3] represents the horizontal and vertical coordinates of the lower right corner of the figure mark; [x4, y4] represents the horizontal and vertical coordinates of the lower left corner of the figure mark.

[0236] S702: Component name position calculation:

[0237] S7021: Grayscale the attached image by calling the cv2.cvtColor function.

[0238] S7022: Binarization, implemented by calling the cv2.threshold function.

[0239] S7023: Contour detection, implemented by calling the cv2.findContours function.

[0240] S7024: Traverse all detected contours, calculate the area of ​​the contours, and ignore contours with too small areas.

[0241] S7025: Calculate the nearest available outline of each reference mark and determine the display position of the component name corresponding to each reference mark.

[0242] S703: According to the dictionary marks_num2ch that maps the input reference marks to component names, and the display position of the component name corresponding to each reference mark output in step S702, the component name and its position information are obtained.

[0243] S704: Using the component name and position information output in step S703, superimpose the component name to the corresponding position.

[0244] Step E: Link the component names in the patent specification to the relevant drawings and figure marks.

[0245] This feature module inputs the component name, a dictionary mapping the component name to the figure mark, all the figures and the figure mark information they contain, and the figure mark information includes the figure mark and its position. Outputs the component name with special effects, the associated figures and the figure mark in the figures and the component name. It is implemented in the component name in the patent specification, and the design and use of effects such as underline or color for modification, and all the figures with the component name are associated, and the design and use of effects such as popping up the related figures when the pointer points to the component name, which is used to display the linked figures and the figure component information, and the component information includes the figure mark and the component name.

[0246] Taking the Chinese patent document with publication number CN108266268A and the implementation effect of its components as an example, the implementation process is given as follows: Figure 4 The process of linking the patent specification component names to the drawings shown involves an algorithm for linking the patent specification component names to the drawings.

[0247] Algorithm 8 Patent specification component name linking algorithm

[0248] Input: component name; dictionary mapping component name to reference numeral; all the figures and their reference numeral information, including reference numerals and their positions.

[0249] Output: the name of the component modified with a special effect; the name of the component with the special effect, the associated drawings, and the drawing mark and component name in the drawings.

[0250] Perform the following steps:

[0251] S801: Construct a dictionary num2drawings using all input drawings and the information of the drawing labels they contain, that is, mapping a drawing label to all drawings containing the drawing label.

[0252] S802: Obtain drawings associated with the component name according to the component name, the dictionary mapping the component name to the drawing number, and the dictionary num2drawings output in S801 (the drawing number is mapped to all drawings containing the drawing number).

[0253] S803: Output the component name with special effects, the associated drawings, the reference numerals in the drawings, and the component name. This is achieved by designing and modifying the component name in the patent specification with effects such as underlining or color, and displaying all associated drawings and component information, including reference numerals and component names.

[0254] Step C: After the reference sign pairs extracted by the named entity recognition model are merged with the reference sign pairs extracted by the rules, the details are as follows:

[0255] After the named entity recognition model extracts the reference symbol pairs, they are fused with the reference symbol pairs extracted by the rules. The algorithm involved is shown in "Algorithm 9: Fusion of named entity recognition model and rule extraction results".

[0256] Algorithm 9: Fusion of named entity recognition model and rule extraction results

[0257] enter:

[0258] (1) Rule extraction results: the reference numeral pairs extracted from the reference numeral descriptions in the patent specification;

[0259] (2) Named entity recognition model extraction results: the reference mark pairs output by "Algorithm 4 Lion King Territory Inspection Algorithm": the reference marks are mapped to the component name dictionary marks_num2ch and the component name is mapped to the reference mark dictionary marks_ch2num.

[0260] Output: The fused dictionary of reference mark pairs, including: reference mark mapping to component name dictionary marks_num2ch and component name mapping to reference mark dictionary marks_ch2num.

[0261] Perform the following steps:

[0262] S901: receiving rules and extraction results of named entity recognition models;

[0263] S9011: Receive rule results: Use rule_marks_num2ch to receive the mapping of the figure marks extracted from the figure mark description of the patent specification to the component name dictionary, and use rule_marks_ch2num to receive the mapping of the component names extracted from the figure mark description of the patent specification to the figure mark dictionary.

[0264] S9012: Receive the extraction results of the named entity recognition model: use marks_num2ch to receive the mapping of the figure marks extracted from the figure mark description of the patent specification to the component name dictionary, and use marks_ch2num to receive the mapping of the component names extracted from the figure mark description of the patent specification to the figure mark dictionary.

[0265] S902: Dictionary merging.

[0266] S9021: Map the reference marks of the traversal rule results to the component name dictionary rule_marks_num2ch:

[0267] Determine the current key-value pair:

[0268] ,

[0269] Among them, curr_num is the key, indicating the current number; part_lst is the value, indicating the parts list corresponding to the current number.

[0270] If the current number curr_num is already in the dictionary marks_num2ch, merge and update the dictionary marks_num2ch. The pseudo code is as follows:

[0271] ,

[0272] Among them, marks_num2ch[curr_num] represents the value of the key curr_num of the dictionary marks_num2ch; list() represents type conversion, converting the parameter type in the brackets into a list type; set() represents type conversion, converting the parameter type in the brackets into a set type; union() represents the union of the set on the left and the set represented by the parameter.

[0273] Otherwise, add the current number curr_num to the dictionary marks_num2ch. The pseudo code is as follows:

[0274] ,

[0275] S9022: Map the component names of the rule results to the reference mark dictionary rule_marks_ch2num:

[0276] Determine the current key-value pair:

[0277] ,

[0278] Among them, curr_part is the key, indicating the current part; num_lst is the value, indicating the number list corresponding to the current part.

[0279] If the current part curr_part is already in the dictionary marks_ch2num, merge and update the dictionary marks_ch2num. The pseudo code is as follows:

[0280] ,

[0281] Among them, marks_ch2num[curr_part] represents the value of the key curr_part of the dictionary marks_ch2num; list() represents type conversion, converting the parameter type in the brackets into a list type; set() represents type conversion, converting the parameter type in the brackets into a set type; union() represents the union of the set on the left and the set represented by the parameter.

[0282] Otherwise, add the current part curr_part to the dictionary marks_ch2num. The pseudo code is as follows:

[0283] ;

[0284] S903: Return marks_num2ch and marks_ch2num.

[0285] Example 2

[0286] Figure 5 This is a schematic diagram of the intelligent indexing system architecture of the patent drawings provided in an embodiment of the present invention, such as Figure 5 As shown, an embodiment of the present invention provides a patent drawing intelligent indexing system 500, including:

[0287] A first extraction module 510 is used to extract the reference numeral pairs in the reference numeral description of the patent specification;

[0288] This module inputs the patent figure mark description and outputs the figure mark pair, realizing the function of extracting the figure mark pair from the figure mark description in the patent text.

[0289] The second extraction module 520 extracts component names using a NER model;

[0290] This module inputs the patent specification text and outputs the component name, realizing the function of extracting component names from the patent text using the NER model.

[0291] Construction module 530, using Lion series algorithm to match reference signs and construct sign pairs;

[0292] This module inputs a list of component names and patent specification text, and outputs figure mark pairs, realizing the function of matching figure marks from patent specifications and constructing figure mark pairs.

[0293] a fusion module 540 that fuses the reference sign pairs extracted by the first extraction module with the reference sign pairs extracted by the second extraction module;

[0294] Display module 550, for linking reference numerals and displaying component names at designated locations;

[0295] This module takes as input a dictionary, marks_num2ch, that maps reference marks to component names, and a drawing. It outputs the drawing with the component name. This module implements the functionality of linking reference marks to patent drawings and displaying the component name at the specified location.

[0296] Linking module 560 is used to link the component names in the patent specification to the relevant drawings and figure mark modules.

[0297] This module inputs the component name, a dictionary mapping from component name to reference mark, all drawings and their reference mark information, including the reference mark and its position. Outputs the component name with special effects, the associated drawings, and the reference mark and component name in the drawings. It is implemented by designing and using effects such as underlining or color to modify the component name in the patent specification, and also by designing and using effects such as popping up related drawings when a pointer points to a component name to display the linked drawings and the component information of the drawings, including the reference mark and the component name.

[0298] The execution process of the patent drawing intelligent indexing system 500 is described in the patent drawing intelligent indexing method mentioned above and will not be repeated here.

[0299] Example 3

[0300] This embodiment provides an electronic device, including: at least one processor and at least one memory;

[0301] The memory is used to store one or more program instructions;

[0302] The processor is used to run one or more program instructions to execute the intelligent patent search method as described above.

[0303] Example 4

[0304] This embodiment provides a computer-readable storage medium, which contains one or more program instructions, and the one or more program instructions are used to execute the intelligent patent search method as described above.

[0305] Although the present invention has been described in detail above using general descriptions and specific embodiments, it will be apparent to those skilled in the art that modifications and improvements may be made thereto. Therefore, such modifications and improvements, without departing from the spirit of the present invention, are intended to be within the scope of protection claimed herein.

Claims

1. A patent drawing intelligent indexing method, characterized in that: include: Step A1, extracting reference numeral pairs from the patent reference numeral description in the patent specification; Step B1, extracting component names from patent text using a named entity recognition (NER) model; Step B2, using the Lion King series algorithm to match the figure mark and construct the figure mark pair, specifically: input the component name list and the patent specification text, output the figure mark pair, realize the function of matching the figure mark from the patent specification and constructing the mark pair; the Lion King series algorithm includes the Lion King Territory Inspection Algorithm, the Lion King Enclosure Algorithm and the Lion King Election Algorithm; wherein the input of the Lion King Territory Inspection Algorithm is the component name list ne_lst and the patent specification all_content, and the output is the figure mark pair, that is, the figure mark is mapped to the component name dictionary marks_num2ch and the component name is mapped to the figure mark dictionary marks_ch2num; in the process of the Lion King Territory Inspection Algorithm traversing the component name and its suffix figure mark matching result list, the Lion King Enclosure Algorithm is called; the input of the Lion King Enclosure Algorithm is to be updated The reference mark is mapped to the component name dictionary marks_num2ch and the component name is mapped to the reference mark dictionary marks_ch2num, the component name and its prefix and suffix reference marks match the string part_num_res, the component name ne, and the updated reference mark is mapped to the component name dictionary marks_num2ch and the component name is mapped to the reference mark dictionary marks_ch2num, and the component name and its prefix and suffix reference marks are processed successfully; in the process of the lion king enclosure algorithm updating the reference mark mapping to the component name dictionary marks_num2ch, after adding the current lion king to the existing lion king list, the lion king election algorithm is called to conduct the lion king election, and the eliminated lion king list to_be_deleted and the winning lion king list win_part_lst are obtained; Step C, merging the reference sign pair constructed in step B2 with the reference sign pair extracted in step A1; Step D, linking the reference numerals and displaying the component names at designated locations; Step E: link the component names in the patent specification to the relevant drawings and figure numbers.

2. The method for intelligent indexing of patent drawings as claimed in claim 1, characterized in that: Wherein step A1, extracting the reference numeral pair from the patent reference numeral description in the patent specification, is implemented by the following steps: Step A11, sorting out the punctuation marks for segmentation, constructing a list of segmentation punctuation marks, and constructing a list of component names and their figure mark separators; Step A12, using separator_lst to segment the patent figure mark description of the patent specification to obtain a string list of component names and their figure marks; Step A13, the character string list of the component names and their reference numerals is segmented using the component name and reference numeral interval symbol list interval_lst to obtain the component names and reference numerals.

3. The method for intelligent indexing of patent drawings as claimed in claim 1, characterized in that: When the component name and its reference numeral cannot be obtained by segmentation in step A12, the prefix and suffix reference numerals are obtained by filtering the prefix and suffix reference numerals through regular expressions.

4. The method for intelligent indexing of patent drawings as claimed in claim 1, characterized in that: The model architecture of the NER model includes: a large model vectorization layer, a bidirectional long-short term neural network layer and a label sequence prediction layer; the data set used for model training adopts a predetermined format, and the NER model is used to predict component names.

5. The method for intelligent indexing of patent drawings as claimed in claim 1, characterized in that: The step D specifically comprises: Input the dictionary marks_num2ch and drawings that map the figure marks to the component names, and output the drawings containing the component names, so as to realize the function of linking the figure marks of the patent drawings and displaying the component names at the specified positions.

6. The method for intelligent indexing of patent drawings as claimed in claim 1, characterized in that: Step E, linking the component names of the patent specification to the relevant drawings and drawing numbers, is achieved by the following steps: Input component names, a dictionary mapping component names to reference numerals, all reference numerals and reference numeral information contained therein, wherein the reference numeral information includes the reference numeral and its position; Output the component name with special effects, the associated drawings, and the drawing marks and component names in the drawings.

7. A patent drawing intelligent indexing system, characterized in that: include: A first extraction module is used to extract the figure mark pairs in the figure mark description of the patent specification; The second extraction module uses the NER model to extract component names; The construction module uses the Lion King series algorithm to match the reference numerals and construct the mark pairs, specifically: input the component name list and the patent specification text, output the reference numeral pairs, and realize the function of matching the reference numerals from the patent specification and constructing the mark pairs; the Lion King series algorithm includes the Lion King Territory Inspection Algorithm, the Lion King Enclosure Algorithm and the Lion King Election Algorithm; wherein, the input of the Lion King Territory Inspection Algorithm is the component name list ne_lst and the patent specification all_content, and the output is the reference numeral pair, that is, the reference numeral is mapped to the component name dictionary marks_num2ch and the component name is mapped to the reference numeral dictionary marks_ch2num; in the process of the Lion King Territory Inspection Algorithm traversing the component name and its suffix reference numeral matching result list, the Lion King Enclosure Algorithm is called; the input of the Lion King Enclosure Algorithm is the to-be-updated The reference mark is mapped to the component name dictionary marks_num2ch and the component name is mapped to the reference mark dictionary marks_ch2num, the component name and its prefix and suffix reference marks match the string part_num_res, the component name ne, and the updated reference mark is mapped to the component name dictionary marks_num2ch and the component name is mapped to the reference mark dictionary marks_ch2num, and the component name and its prefix and suffix reference marks are processed successfully; in the process of the lion king enclosure algorithm updating the reference mark mapping to the component name dictionary marks_num2ch, after adding the current lion king to the existing lion king list, the lion king election algorithm is called to conduct the lion king election, and the eliminated lion king list to_be_deleted and the winning lion king list win_part_lst are obtained; a fusion module, which fuses the reference sign pair extracted by the first extraction module with the reference sign pair extracted by the second extraction module; A display module, used to link the reference numerals and display the component names at designated locations; A linking module is used to link the component names in the patent specification to the relevant drawings and figure marking modules.

8. An electronic device, characterized in that: The electronic device comprises: at least one processor and at least one memory; The memory is used to store one or more program instructions; The processor is used to run one or more program instructions to execute the method according to any one of claims 1-6.

9. A computer-readable storage medium, characterized in that The computer-readable storage medium includes one or more program instructions, and the one or more program instructions are used to execute the method according to any one of claims 1 to 6.

Images