Intelligent indexing method and system for patent drawings

Through the combination of the named entity recognition model and the Lion King series algorithm, the problem of insufficient generalization ability and one-to-many mapping relationship in patent reference mark recognition is solved, and efficient and accurate reference mark recognition and component name display are achieved, improving the improvement of Review efficiency and user experience.

CN118917278AActive Publication Date: 2024-11-08BEIJING ZHIGUAGUA TECH CO LTD
View PDF 7 Cites 0 Cited by

Patent Information

Application Number
CN202411412226.2
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2024-10-11
Publication Date
2024-11-08
Estimated Expiration
2044-10-11

AI Technical Summary

Technical Problem

The prior art lacks model-based generalization capabilities in patent reference numerals recognition, and cannot effectively handle the one-to-many mapping relationship, resulting in low recognition efficiency and insufficient accuracy.

Method used

The named entity recognition (NER) model is used to combine the Lion King series algorithm to extract and match the reference marks, build a reference mark pair, and display the component names at the specified locations, supporting a one-to-many mapping relationship.

Benefits of technology

It improves the identification accuracy of patent reference numerals and user reading experience, improves the review efficiency, is suitable for the recognition of composite word type component names, and combines the excellent performance of rules and models.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118917278A_ABST
    Figure CN118917278A_ABST
Patent Text Reader

Abstract

The invention discloses a patent attached drawing intelligent indexing method and system. The method comprises the following steps: extracting an attached drawing mark pair from patent attached drawing mark description of a patent specification; extracting component names from the patent text by using a named entity recognition NER model; adopting a lion king series algorithm to match the attached map marks and constructing attached map mark pairs; fusing the extracted attached drawing mark pair with the attached drawing mark link of the patent attached drawing, and displaying the name of the component at a specified position; component names in the patent specification are linked with related attached drawings and attached drawing marks. The problem that the number of words needs to be considered during component name extraction is avoided, the method is suitable for component name extraction of compound word types, and the effect of combining the excellent performance of rules and the generalization ability of models in the performance aspect is achieved. And the reading experience of the user is enhanced while the efficiency is improved.
Need to check novelty before this filing date? Find Prior Art

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 intelligently indexing patent drawings. Background Art

[0002] The Patent Examination Guidelines stipulate that "the reference numerals shall be numbered in 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 content and extract the component names in the drawings. When the content of the patent application document is large, it is inconvenient to check whether the reference numerals and the component names mapped to them are correct. There are problems such as time-consuming and laborious comparison of the specification text and the reference numerals, low review efficiency and easy errors.

[0003] In the Chinese patent text named "A patent intelligent drawing generation method and system" and publication number CN116168411A, by identifying the figure marks in the figure file, identifying the characteristic marks and characteristic nouns in the specification file, and obtaining the correspondence between the characteristic marks and characteristic nouns, the figure marks in the figure file and the characteristic marks in the specification are matched, so that the figure marks in the figure file can correspond to the characteristic nouns in the specification file, and then the characteristic nouns expressed by the figure marks are displayed in the figure file. Through this method, the meaning expressed by the figure marks can be clearly displayed, which improves the reviewer's experience when reading.

[0004] This patent application solution extracts characteristic markers and characteristic nouns and establishes a matching relationship between 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. The phrase pairs with the most occurrences are used to eliminate the problem of more local phrase pairs due to writing errors 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, which uses multiple patent specification samples based on text mining technology to establish figure mark description extraction rules, and a method for extracting figure mark descriptions in patent specifications based on the established figure mark description extraction rules, wherein the figure mark description refers to the entity represented by the text such as the component name corresponding to the figure mark in the specification or claim. The rule extraction steps include: (1) classifying the multiple patent specification samples according to the application country; (2) extracting common features according to the classified application countries; (3) establishing the figure mark description extraction rules based on the extracted features. The rules, for example, in the case of Korea, can be extracted as common features that the figure mark description is located before the figure mark, the figure mark is contained in two brackets, etc., and in the case of the United States, can be extracted as common features that the figure mark description is located before the figure mark, the figure mark is written in bold, and the figure mark is not distinguished by two brackets like in Korea. Depending on the country of application, there is a case where the patent specification has a 'symbol description' category that separately records the figure mark and the figure mark description. This can also be extracted as a common feature, and the 'symbol description' category can be used to extract the figure mark description later. After studying various patent specification samples, various common features can also be extracted according to the country of application. After establishing the figure mark description extraction rules (or models) based on the common features extracted in this way, the figure mark description is extracted from the patent specification using them. An embodiment is proposed in which, when multiple figure mark descriptions are extracted, after searching the multiple figure mark descriptions extracted from the patent specification, the figure mark description with the largest amount of search is determined as the final figure mark description for extraction. It is proposed that the number of words in the figure mark description is limited to a preset number based on the figure mark description data accumulated so far, that is, the number of words in all the compound words of the mark description database is counted, and the number of words with a statistically low extraction rate / probability is set to a limited number. When the probability of a compound word with more than five words being extracted as a figure mark description is 0.0001%, a maximum of four words are used as the figure mark description.

[0006] The disclosed patent figure mark recognition method completely implements figure mark description extraction based on rules, and lacks the generalization ability of model-based extraction methods. In addition, the method proposed by the patent to extract multiple figure mark descriptions from a mark and determine the figure mark description with the largest search volume as the final figure mark description may not be 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, the "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". For another example, "a metal plate strip heat treatment drying device" (Chinese patent text with publication number CN111947428B) contains the expressions "metal plate strip 3" and "metal plate strip plate 3", and the number 3 corresponds to the two component names "metal plate strip" and "metal plate strip plate". It is proposed that the number of words in the figure mark description is limited to a preset number based on the figure mark description data accumulated so far, that is, the number of words in all the compound words of the mark description database is counted, and the number of words with a low statistical extraction rate / probability is set to a limited number, and a maximum of four words are used as the figure mark description. The threshold value calculated by statistics depends on the distribution of the accumulated database, and the figure mark description longer than 5 words is discarded. The number of characters on the left side of the number is limited to extract the mark description. The extraction of compound word type mark description still needs to study more accurate and efficient extraction methods. 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 the review efficiency while enhancing the 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, extracting component names from patent text using a named entity recognition (NER) model;

[0012] Step B2, using the Lion series algorithm to match the 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 rule in step A1;

[0014] Step D, linking the reference numerals of the patent drawings and displaying the component names at designated locations;

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

[0016] Preferably, the step A1 extracts the reference numeral pairs from the patent reference numeral description in the patent specification, which is implemented by the following steps:

[0017] 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;

[0018] Step A12, using 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, using the component name and its reference numeral interval symbol list interval_lst to segment the component name and 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 NER model is used to predict component names.

[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 comprises:

[0027] 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.

[0028] 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 reference numerals and reference numeral information contained therein, 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] In another aspect, the present invention provides a patent drawing intelligent indexing system, comprising:

[0032] A first extraction module is used to extract the figure mark pairs in the figure mark 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, which fuses the reference sign pair extracted by the first extraction module with the reference sign pair extracted by the second extraction module;

[0036] A display module, used to link the reference numerals and display the 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 component names and component names of patent specifications 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 annotation cost.

[0041] The invention of this application proposes a patented component name recognition method, which implements 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 using a model, thereby avoiding the problem of considering the number of words in component name extraction. The method is suitable for extracting component names of compound word types, 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] In order to more clearly illustrate the implementation methods of the present invention or the technical solutions in the prior art, the drawings required for the implementation methods or the description of the prior art are briefly introduced below. Obviously, the drawings in the following description are only exemplary, and for ordinary technicians in this field, other implementation drawings can be derived from the provided drawings without creative work.

[0044] The structures, proportions, sizes, etc. illustrated in this specification are only used to match the contents disclosed in the specification so as to facilitate understanding and reading by persons familiar with the technology. They are not used to limit the conditions under which the present invention can be implemented, and therefore have no substantial technical significance. Any structural modification, change in proportion or adjustment of size shall still fall within the scope of the technical contents disclosed in the present invention without affecting the effects and purposes that can be achieved by the present invention.

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

[0046] Figure 2 A 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 name flow chart at the designated location;

[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 is a description of the implementation of the present invention by specific embodiments. People familiar with the art can easily understand other advantages and effects of the present invention from the contents disclosed in this specification. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0051] This application proposes a patent drawing intelligent indexing method, 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 reference numerals: Based on reference numerals, component names, and reference numeral pairs, the following two functions are realized:

[0055] <1> Reference numerals are linked and part 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] Embodiment 1

[0058] Reference Figure 1 , a patent drawing intelligent indexing method provided by an embodiment of the present invention includes:

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

[0060] Step B1, extracting component names from patent text using a named entity recognition (NER) model;

[0061] Step B2, using the Lion series algorithm to match the 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 numbers.

[0065] The following describes each step in detail:

[0066] Step A1, extracting reference numeral pairs from the reference numeral description of 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 steps of:

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

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

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

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

[0072] Step A12: Use the separator punctuation 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 of the component name and its reference numeral to obtain the component name and reference numeral. If the component name and its reference numeral cannot be obtained by segmentation in step A12, the prefix and suffix reference numerals can be obtained by filtering the prefix and suffix reference numerals through regular expressions, which involves "Algorithm 1 Regular expression matching prefix and suffix extraction reference numeral and component name".

[0074] Algorithm 1: Regular expression matching prefix and suffix to extract reference numerals 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] Follow these 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 figure mark extraction result of re.findall(), which is a list structure type; re.findall() is a regular method used to find all figure marks that meet the regular expression; sub_mark is a string consisting of the component name and the figure 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 it is of list structure type; 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 pseudocode 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 it is of list structure type; 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 the drawing reference are not empty, and verify the consistency of the number of the part name and the drawing reference.

[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, realizing 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] As Figure 2 shown in the NER model architecture, it includes: a large model vectorization layer, a bidirectional long short-term neural network layer, and a label sequence prediction layer.

[0094] Among them, 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 AutoModel.from_pretrained(ernie_config) method of transformers to load it. The parameter ernie_config represents the model configuration class.

[0095] The 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 parameter embedding_dim represents the embedding vector dimension value; the parameter hidden_dim represents the hidden layer dimension value; the parameter num_layers=rnn_layers represents the number of recurrent neural network layers; the parameter bidirectional=True represents bidirectional; the parameter dropout=dropout_ratio represents the random dropout rate; batch_first=True represents the batch size in the first dimension of the tensor.

[0096] The label sequence prediction layer is encoded by conditional random fields, and then the Viterbi algorithm is used to obtain a 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 data set format used for the NER model training is shown in “Table 2 NER model training data set format”.

[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 Patent NER model training

[0106] Input: Dataset used for NER model training

[0107] Output: trained NER model

[0108] Follow these 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, mainly including: 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 the model configuration information, including: data set 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, 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 and short-term neural network layer, label sequence prediction layer. The pseudo code for the bidirectional long-term and 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] Among them, the parameter embedding_dim indicates the embedding vector dimension value; the parameter hidden_dim indicates the hidden layer dimension value; the parameter num_layers=rnn_layers indicates the number of recurrent neural network layers; the parameter bidirectional=True indicates bidirectional; the parameter dropout=dropout_ratio indicates the random dropout rate; batch_first=True indicates that the batch size is placed 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: Specify to use the Adam optimization algorithm to define the optimizer optimizer.

[0123] S204: Set model training hyper parameters 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 loss, based on the negative log-likelihood function definition formula as follows:

[0127] (1)

[0128] in, represents the loss function, which 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 (number of time steps); Represents the kth feature function, whose input is two adjacent labels y t-1 and 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 and 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] Follow these 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 are mapped to component name dictionary marks_num2ch and component names are mapped to reference mark dictionary marks_ch2num.

[0153] step:

[0154] S401: Identify the smell of lions, define the regular expression of the reference symbol:

[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 list of component names 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 based on 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 smell of the current lion king and lion group, and construct a regular expression matching the current component name and its reference mark:

[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 regular expression that matches a suffix reference symbol; re_partnum_ext is a regular expression that matches a prefix reference symbol.

[0165] S4042: Set the need_prefix_process flag to True to check whether prefix code processing is required, and implement suffix code 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 figure mark string as parameters, calls "Algorithm 5 Lion King Circle Algorithm", updates the figure mark mapping to the component name dictionary marks_num2ch and the component name mapping to the figure 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 flag need_prefix_process = False.

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

[0172] S40441: Execute prefix figure mark processing.

[0173] S40442: Traverse the list of matching results of the component name and its prefix reference number part_num_res_prefix_lst:

[0174] S404421: The current lion king circles the land for the second time, passes the current component name and its prefix figure mark string as parameters, calls "Algorithm 5 Lion King Circle Algorithm", updates the figure mark mapping to the component name dictionary marks_num2ch and the component name mapping to the figure mark dictionary marks_ch2num.

[0175] S405: Return the reference mark pair: that is, 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.

[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 matched by 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] Follow these steps:

[0180] S501: The lion king obtains nearby odors and extracts the partial 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 nearby; 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 match flag and initialize it to False:

[0184] FIND_NUM=False;

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

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

[0187] Among them, curr_num_lst is a list consisting of the segmented figure marks.

[0188] S504: traverse the location of each smell, that is, the reference numeral 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 numeral is illegal, and if so, proceed to the next reference numeral processing.

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

[0192] S50431: Get the existing lion list, and take out 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 a list of existing component names 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 take out 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 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 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 lions, that is, the list of removed component names to_be_deleted, and the winning lions, that is, the list of retained component names win_part_lst.

[0210] Follow these 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, jump out of S603 and execute S604.

[0215] S6032: Otherwise, start inner iteration and traverse all the 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 whose length satisfies formula 2 after the current outer iterative lion, the current outer iterative lion is added to the eliminated lion list to_be_deleted.

[0219] (2)

[0220] in, is the length of the name of any subsequent Lion component; The length of the current Lion component name; Indicates between 1 times the length of the Lion component name 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, linking the reference numerals of the patent drawings and displaying the component names at designated locations;

[0224] This feature module inputs the dictionary marks_num2ch that maps reference marks to component names and the drawings. It outputs the drawings containing component names. It implements the function of linking the reference marks of patent drawings and displaying the component names at the specified position.

[0225] Take the implementation effect of the Chinese patent text drawings and component names of publication number CN108266268A as an example. Figure 3 Link the patent figure mark and display the component name flow chart at the specified location, such as Figure 3 As shown, the implementation process is given, the figure numerals are connected and the component name algorithm is displayed.

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

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

[0228] Output: Drawing with part names.

[0229] Follow these steps:

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

[0231] [num1, …],

[0232] Among them, 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 figure by calling cv2.cvtColor function.

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

[0239] S7023: Contour detection, implemented by calling 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 contour for each reference numeral, and determine the display position of the component name corresponding to each reference numeral.

[0242] S703: Map the input reference numerals to the dictionary marks_num2ch of the component names, and obtain the component names and their position information according to the corresponding component name display positions of the reference numerals output in step S702.

[0243] S704: Using the component name and its 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 numbers.

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

[0246] Taking the Chinese patent text drawings and the implementation effects 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 link diagram algorithm

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

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

[0250] Follow these steps:

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

[0252] S802: Obtain drawings associated with the component names according to the component names, the dictionary mapping the component names to the drawing numbers, and the dictionary num2drawings (the drawing numbers are mapped to all drawings containing the drawing numbers) outputted in S801.

[0253] S803: Output the component name with special effects, the associated drawings, and the reference numerals and component names in the drawings. The component name in the patent specification is designed and modified with effects such as underline or color, and all associated drawings and component information of the drawings are displayed, and the component information includes 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 sign pairs, they are fused with the reference sign 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: pairs of reference numerals extracted from the description of reference numerals in the patent specification;

[0259] (2) Named Entity Recognition Model Extraction Result: The reference mark pair output by “Algorithm 4 Lion King Territory Inspection Algorithm”: 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.

[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] Follow these steps:

[0262] S901: receiving the extraction result of the rule and the named entity recognition model;

[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] Embodiment 2

[0286] Figure 5 Schematic diagram of the intelligent indexing system architecture of the patent drawings provided in the 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 patent figure mark descriptions and outputs figure mark pairs, thus realizing the function of extracting figure mark pairs from the figure mark descriptions 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 names, 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 numerals and construct a pair of numerals;

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

[0293] A fusion module 540, which fuses the reference sign pair extracted by the first extraction module with the reference sign pair extracted by the second extraction module;

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

[0295] This module inputs the dictionary marks_num2ch that maps reference marks to component names and drawings. Outputs drawings containing component names. Implements the function of linking reference marks of patent drawings and displaying component names at specified locations.

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

[0297] This module inputs the component name, a dictionary mapping from 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. Output the component name with special effects, the associated figures, and the figure mark and component name in the figures. Implement the design and use of effects such as underline or color to modify the component name in the patent specification, and associate all the figures with the component name, design and use effects such as popping up the related figure when the pointer points to the component name, which is used to display the linked figure and the figure component information, and the component information includes the figure mark and the component name.

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

[0299] Embodiment 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] Embodiment 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 by general description and specific embodiments, it is obvious to those skilled in the art that some modifications or improvements can be made to the present invention. Therefore, these modifications or improvements made without departing from the spirit of the present invention all belong to the scope of protection claimed by the present invention.

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 series algorithm to match the reference numerals and construct reference numeral pairs; 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; 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 the separator punctuation list separator_lst to segment and obtain a character string list of component names and their reference numerals; Step A13, using the component name and its reference numeral interval symbol list interval_lst to segment the component name and reference numeral.

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 NER model includes: NER model architecture, NER model training, and NER model application. The NER model architecture 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 the NER model training is in a predetermined format; The NER model is trained 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 Lion King series of algorithms include the Lion King territory inspection algorithm, the Lion King enclosure algorithm and the Lion King election algorithm.

6. 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.

7. 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.

8. 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 series algorithm to match the reference marks and construct the mark pairs; 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.

9. 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-7.

10. A computer-readable storage medium, characterized in that The computer-readable storage medium contains 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 7.

Citation Information

Patent Citations

  • Patent file processing method and device and storage medium

    CN109598649A

  • Automatic extraction method and system for component names in patent text, terminal and readable storage medium

    CN112380856A

  • Patent attached drawing mark description output method and device and system used for patent attached drawing mark description output method

    CN115427944A

  • Intelligent patent attached drawing generation method and system

    CN116168411A

  • Block chain patent named entity identification method and system based on deep learning

    CN117852544A