Technical life cycle prediction method and system based on patent data

Abstract

The invention belongs to the technical field of patent analysis, and provides a technology life cycle prediction method and system based on patent data, and the method comprises the steps: obtaining the feature data of patents in a patent database; inputting the feature data into a plurality of trained prediction models to obtain a plurality of first prediction results of the technical life cycle; fusing the plurality of first prediction results through a voting mechanism to obtain a second prediction result of the technical life cycle; according to the method, accurate prediction can be provided in each stage of a technology life cycle based on patent data by combining quantitative analysis of characteristic data of patents and a machine learning algorithm, the dependency of a qualitative analysis method on expert experience is overcome, and the limitation of a quantitative analysis method in emerging technology prediction is overcome.

Description

Technical Field

[0001] The present invention belongs to the technical field of patent analysis, and in particular relates to a method and system for predicting a technology life cycle based on patent data. Background Art

[0002] With the development of the Internet, big data and artificial intelligence, the update speed of domestic and foreign patent data is accelerating. For universities, research institutions and enterprises, it is particularly important to accurately judge the life cycle of technology for the formulation of technology development strategies. As far as the technology life cycle is concerned, it includes the introduction period, growth period, maturity period and decline period, and the characteristics of patent data at different stages of the technology life cycle are not the same. For this reason, the technology life cycle prediction based on patent data can help universities, research institutions and enterprises to formulate reasonable technology development strategies.

[0003] At present, the main methods for predicting technology life cycle are qualitative analysis and quantitative analysis. Specifically, qualitative analysis mainly relies on expert experience and judgment, which is highly subjective and the accuracy of its prediction results is difficult to guarantee; quantitative analysis mainly conducts statistical analysis based on historical data, which is highly objective, but requires a large amount of data support and is not effective for predicting emerging technologies. Summary of the invention

[0004] In view of the problems in the background technology, the present invention proposes a technology life cycle prediction method and system based on patent data.

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

[0006] In a first aspect, the present disclosure proposes a technology life cycle prediction method based on patent data, comprising:

[0007] Obtain characteristic data of patents in patent database;

[0008] Inputting the characteristic data into a plurality of trained prediction models to obtain a plurality of first prediction results of the technology life cycle;

[0009] Multiple first prediction results are integrated through a voting mechanism to obtain a second prediction result of the technology life cycle.

[0010] Furthermore, the acquisition of characteristic data of patents in the patent database includes:

[0011] Patents in the patent database are obtained through multi-threaded crawler technology, where each thread has a different patent classification number;

[0012] Extract characteristic data of the patent.

[0013] Furthermore, before extracting the characteristic data of the patent, it also includes: preprocessing the patent.

[0014] Furthermore, multiple prediction models are trained, including:

[0015] Obtaining patent training features and training labels, and constructing a data set based on the training features and training labels;

[0016] Dividing the data set into a training set and a test set;

[0017] The prediction model is trained using the training set to obtain a preliminarily trained prediction model, and the preliminarily trained prediction model is tested using the test set to obtain a trained prediction model.

[0018] Further, the characteristic data includes technical fields;

[0019] Extracting characteristic data of the patent includes: obtaining the technical field to which the patent belongs through the patent classification number.

[0020] Furthermore, the technical field to which the patent belongs obtained by the patent classification number includes:

[0021] Construct a mapping table between patent classification numbers and technical fields;

[0022] In response to the input of the patent classification number, the patent classification number is obtained, and based on the patent classification number and the mapping table, the technical field to which the patent belongs is obtained.

[0023] Furthermore, the characteristic data includes keywords of the patent title and abstract;

[0024] Extract characteristic data of the patent, including:

[0025] Traverse the patents and calculate the word frequencies of the patent titles and abstracts of the patents;

[0026] Calculate the inverse document frequency of the patent title and abstract;

[0027] The weight is obtained by multiplying the word frequency and the inverse document frequency, and keywords are filtered according to the weight and a preset number of keywords.

[0028] Furthermore, the characteristic data includes innovation degree;

[0029] Extract characteristic data of the patent, including:

[0030] Convert the keywords and technical fields into feature vectors;

[0031] Calculate the similarity between the patent and historical patents;

[0032] Calculate the average similarity through the similarities;

[0033] The novelty is calculated by the average similarity.

[0034] Furthermore, the characteristic data includes innovation degree;

[0035] Extract characteristic data of the patent, including:

[0036] Convert the keywords and technical fields into feature vectors;

[0037] Calculate the similarity between the patent in question and historical patents:

[0038] Calculate the time difference between the publication date of the patent and the historical patent;

[0039] Calculating a decay factor using the time difference;

[0040] Multiplying the similarity by an attenuation factor to obtain an attenuated similarity;

[0041] Calculating the attenuated average similarity through the attenuated similarity;

[0042] The innovation degree is calculated by the average similarity after attenuation.

[0043] In a second aspect, the present disclosure proposes a technology lifecycle prediction system based on patent data, comprising:

[0044] An acquisition module, used to acquire characteristic data of patents in a patent database;

[0045] A first prediction module, used for inputting the characteristic data into a plurality of trained prediction models to obtain a plurality of first prediction results of the technology life cycle;

[0046] The second prediction module is used to fuse multiple first prediction results through a voting mechanism to obtain a second prediction result of the technology life cycle.

[0047] Beneficial effects of the present invention:

[0048] The method of the present invention, by combining quantitative analysis of patent feature data and machine learning algorithms, can provide accurate predictions at various stages of the technology life cycle based on patent data. It not only overcomes the reliance of qualitative analysis methods on expert experience, but also overcomes the limitations of quantitative analysis methods in the prediction of emerging technologies. It also adopts a dual feature extraction method based on patent classification numbers and text mining, which makes the feature extraction of patent data more accurate and provides more reliable input data for technology life cycle prediction.

[0049] Other features and advantages of the present invention will be described in the following description, and partly become obvious from the description, or be understood by implementing the present invention. The purpose and other advantages of the present invention can be realized and obtained by the structures pointed out in the description and the drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0050] In order 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 use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0051] Figure 1 A flow chart showing a method for predicting technology life cycle based on patent data of the present invention is shown;

[0052] Figure 2 The device framework diagram of the present invention is shown;

[0053] Figure 3 A schematic diagram of the device structure of the present invention is shown. DETAILED DESCRIPTION

[0054] In order to make the purpose, technical solution and advantages of the embodiments of the present invention clearer, the technical solution in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. 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.

[0055] Reference Figure 1 As shown, a technology life cycle prediction method based on patent data is shown, and the method specifically includes the following steps:

[0056] S1. Obtain characteristic data of patents in the patent database;

[0057] Patent database refers to a database system specifically used to store, manage and retrieve patent information. For example: CNIPA (China National Intellectual Property Administration), USPTO (United States Patent and Trademark Office), DPMA (German Patent and Trademark Office), etc. These databases contain a large number of patent texts, such as patent applications, specifications, specification drawings, claims, abstracts, abstract drawings, etc., as well as relevant information about patents, such as patent number, application date, authorization date, patentee, inventor, patent classification number, etc.

[0058] In an exemplary embodiment of the present disclosure, obtaining patent data from a patent database specifically includes:

[0059] S11. Obtain patents from the patent database through multi-threaded crawler technology; each thread has a different patent classification number;

[0060] Specifically, each thread is first assigned a different patent classification number to ensure the comprehensiveness and diversity of the collected data. Then, the multi-threaded crawler technology based on Scrapy parses HTML pages or calls the API provided by the target database to batch obtain patent texts from the target patent database. These texts include patent names, patent application numbers, patent application dates, patent authorization dates, specifications, specification drawings, claims, abstracts, etc.

[0061] S2, pretreatment patent;

[0062] The original patent text contains a lot of noise and irrelevant information, which will interfere with the effectiveness and accuracy of the NLP algorithm. Therefore, it is necessary to clean up these noises through preprocessing steps to make the patent data cleaner and more standardized, so as to be more suitable for subsequent NLP tasks.

[0063] Use text cleaning technology to remove irrelevant fields and unify the data format. Specifically include:

[0064] Date format: All date-related fields are unified into a standard format (such as YYYY-MM-DD). Data from different sources may use different date formats (such as DD / MM / YYYY or MM-DD-YYYY). Through formatting, all date fields are converted to a consistent format for subsequent processing and analysis.

[0065] Text format: For text fields such as patent name, applicant name, classification number, etc., unified processing is performed. For example, redundant spaces are removed, punctuation marks are consistent, and upper and lower case are unified to ensure that the text fields are stored in a unified form in the database.

[0066] Numeric format: For fields involving quantities, amounts, or other numeric data, ensure that they are stored in a uniform numeric format in the database (such as integers or decimals). This may also include removing thousands separators from values ​​or standardizing all values ​​to a specific unit.

[0067] Field name and structure: Before storing data in the database, ensure that the name and data type of each field (such as patent application number, patent application date, patent classification number, etc.) are unified. For example, if a field in the data obtained from different sources uses a different name or format, it needs to be converted before storage to make it conform to the field definition of the database.

[0068] Through the above steps, the unified data format ensures the consistency of all data in structure, type and representation, which is crucial for subsequent data analysis and machine learning model training. Regular expressions are used to remove noise data to ensure high data quality. In order to further improve the validity of the data, the module has a built-in duplicate detection algorithm that uses the MD5 hash function to identify and delete duplicate patent records.

[0069] S3, extracting characteristic data of the patent, and inputting the characteristic data into multiple trained prediction models to obtain multiple prediction results;

[0070] Patent feature data refers to the features extracted from the patent, including technical field, degree of innovation, patent application date, patent classification number, keywords (extracted through TF-IDF), number of patent citations, patent applicant, etc.

[0071] As a preferred embodiment, the prediction model is a support vector machine (SVM), a random forest (RandomForest) or a neural network (Neural Network). The support vector machine distinguishes different categories by finding an optimal hyperplane. The random forest is an integrated learning model composed of multiple decision trees, each tree makes a prediction independently, and the final prediction result is obtained by voting or averaging. The neural network learns complex feature mapping relationships through multiple hidden layers and nonlinear activation functions.

[0072] In an exemplary embodiment of the present disclosure, the step of training a prediction model specifically includes:

[0073] S311. Obtain patent features and labels and build a data set;

[0074] The label of the patent text refers to the corresponding technology life cycle stage label, which can be divided into the introduction period (Introduction), growth period (Growth), maturity period (Maturity), and decline period (Decline). Among them, the introduction period is the stage when the technology just appears. The technical performance at this stage may not be stable enough, the cost is high, the market awareness is low, and the types of products or services are relatively small; the growth period is the stage when the technology is widely accepted by the market. The technical performance at this stage is constantly improving, the cost is gradually reduced, the market demand is rapidly growing, and the types of products or services are constantly enriched; the maturity period is the stage when the technology development is relatively stable. At this stage, the market demand slows down, the technical performance is basically stable, the cost is relatively low, and the market competition is fierce; the decline period is the stage when the technology is gradually replaced by the new technology. At this stage, the market demand continues to decline and the technical performance lags behind the new technology. Labels can be annotated based on historical data or manually annotated. The training set includes the features and labels of the patent text.

[0075] Taking building a dataset in Python as an example, it includes:

[0076] Example feature data:

[0077] Define a list called features. Each element in this list is a nested list, representing a feature vector of a patent. Each feature vector contains multiple values, which may represent different attributes or features of the patent, such as application date, patent classification number, TF-IDF value of keywords, etc.

[0078] Exemplary:

[0079] The first nested list [0.1, 0.5, 0.2, 0.7] represents the eigenvector of patent 1, which contains 4 eigenvalues.

[0080] The second nested list [0.4, 0.3, 0.6, 0.1] represents the eigenvector of Patent 2, which also contains 4 eigenvalues.

[0081] Sample label data: Define a list called labels, each element in this list is a string, which represents the label of the corresponding patent's technology life cycle stage. These labels can include, for example, "growth", "maturity", "introduction", "decline", etc.

[0082] Exemplary:

[0083] The first label 'growth' corresponds to the first feature vector, which means that the life cycle stage of patent 1 is the growth stage.

[0084] The second label 'maturity' corresponds to the second feature vector, which means that the life cycle stage of patent 2 is maturity.

[0085] S312, dividing the data set into a training set and a test set;

[0086] As a preferred embodiment, the ratio of the training set to the test set is 80:20, that is, 80% of the data is used to train the model, and the remaining 20% ​​is used to evaluate the performance of the model.

[0087] S313, using the training set to train the prediction model to obtain a preliminarily trained prediction model, and using the test set to test the preliminarily trained prediction model to obtain a trained prediction model;

[0088] Finally, the performance of the fusion model is evaluated by calculating indicators such as accuracy, precision, recall, and F1 score.

[0089] For example, taking the training of a support vector machine model (SVM), a random forest model (RandomForest) and a neural network model (Neural Network) in Python as an example, the specific examples include:

[0090] Import necessary libraries: Import the train_test_split function from the sklearn.model_selection module. This function is used to split the dataset into training and test sets.

[0091] Dataset splitting: Use the train_test_split function to split the feature data features and label data labels into training and test sets according to the specified ratio. Among them, features contains the feature vector of the patent, and labels contains the corresponding technology life cycle stage label.

[0092] Specify the test set ratio: The parameter test_size = 0.2 means that 20% of the data is allocated to the test set, and the remaining 80% of the data is used for the training set. The test set is used to evaluate the performance of the model, and the training set is used to train the model.

[0093] Set random seed: The parameter random_state=42 is a random seed used to ensure that the splitting method of the dataset is consistent each time the code is run. This is very useful when debugging and reproducing experimental results.

[0094] Split results: After running train_test_split, the data will be split into four parts:

[0095] X_train: Feature dataset used for training, accounting for 80% of the total dataset.

[0096] X_test: Feature dataset used for testing, accounting for 20% of the total dataset.

[0097] y_train: Label dataset used for training, corresponding to X_train.

[0098] y_test: Label data set for testing, corresponding to X_test.

[0099] Support vector machine training:

[0100] Import the support vector machine (SVM) model:

[0101] Import the SVC class from the sklearn.svm module, which is the class used to build a Support Vector Classifier (SVM).

[0102] Initialize the SVM model:

[0103] Create an instance of the SVC class and name it svm_model. During initialization, set the probability = True parameter, which allows the model to return predicted probabilities instead of just class labels when making predictions. This is very useful in some application scenarios that require probability output.

[0104] Train the SVM model:

[0105] Use the svm_model.fit(X_train,y_train) method to pass the previously split training set feature data X_train and training set label data y_train to the model and start training. During the training process, the SVM model will find an optimal hyperplane to distinguish categories based on the training data.

[0106] Random Forest Training:

[0107] Import the random forest classifier:

[0108] Import the RandomForestClassifier class from the sklearn.ensemble module, which is used to build a random forest classifier. Random forest is an ensemble learning algorithm that performs classification by building multiple decision trees and voting on their results.

[0109] Initialize the random forest model:

[0110] Create an instance of the RandomForestClassifier class and name it rf_model. During initialization, two key parameters are set:

[0111] n_estimators = 100: This parameter specifies the number of decision trees in the random forest. Here, it is specified that the random forest consists of 100 decision trees.

[0112] random_state=42: Set the random seed to ensure that the results of model training are repeatable. This parameter is used to fix randomness and facilitate the reproduction of experimental results.

[0113] Train a random forest model:

[0114] Use the rf_model.fit(X_train,y_train) method to pass the previously split training set feature data X_train and training set label data y_train to the model and start training. During the training process, the random forest model will build multiple decision trees based on the training data and improve the classification accuracy by integrating the prediction results of these decision trees.

[0115] S4. Multiple prediction results are integrated through a voting mechanism to obtain a final prediction result (second prediction result).

[0116] By extracting the characteristic data of patents, adopting multiple machine learning algorithms such as support vector machines, random forests and neural networks, and using a voting mechanism to fuse their prediction results, the accuracy of technology life cycle prediction can be effectively improved.

[0117] In an exemplary embodiment of the present disclosure, in step S3, the extracted characteristic data of the patent are the technical field, keywords and innovation degree of the patent name and abstract; wherein the innovation degree is calculated based on the technical field and keywords of the patent name and abstract.

[0118] The technical fields of the extracted patents include:

[0119] S32. Obtain the technical field to which the patent belongs through the patent classification number;

[0120] Patent classification numbers (such as IPC classification numbers) are a standardized tool for classifying and identifying patents. Each patent is assigned one or more patent classification numbers, which correspond to specific technical fields or technical topics. For example, "C22C" represents alloys. By establishing a mapping relationship between classification numbers and technical fields, the technical fields of patents can be automatically identified and marked.

[0121] S321. Construct a mapping table between patent classification numbers and technical fields;

[0122] S322, in response to the input of the patent classification number, obtaining the patent classification number, and obtaining the technical field to which the patent belongs according to the patent classification number and the mapping table;

[0123] Taking the identification of the technical field to which a patent belongs by patent classification number in Python as an example, the specific examples include:

[0124] Define the mapping relationship between classification numbers and technical fields: First, define a dictionary classification_map, where each key is a patent classification number (such as "C22C" or "G06F"), and each corresponding value is the technical field to which the classification number belongs (such as "Alloy" or "Computer Technology"). It can be understood that the dictionary can be expanded, and more mapping relationships between classification numbers and their corresponding technical fields can be added as needed.

[0125] Define a function to identify the technology field: Define a function called identify_technology_field, which accepts a classification code classification_code as input. The function will look up the key-value pair in the classification_map dictionary and return the corresponding technology field. If the corresponding classification code is not found in the dictionary, the function will return the default value "UnknownField" (unknown field). For example, by calling identify_technology_field("C22C"), passing in the classification code "C22C", the function will return "Alloy", which is the technology field corresponding to the classification code. If the passed in classification code has no corresponding item in the dictionary, the function will return "Unknown Field".

[0126] By mapping patent classification numbers to corresponding technical fields, it helps to automatically identify the technical field to which the patent belongs. By expanding the dictionary classification_map, more patent classification numbers and their corresponding technical fields can be covered, making it easier to classify and analyze patent data.

[0127] Extract the keywords of patent names and abstracts, including:

[0128] S33, extracting keywords from the patent name and abstract of the patent, calculating the weight of each keyword, and filtering the keywords according to the weight;

[0129] S331, Patent title and abstract of processing patents;

[0130] For example, the patent name and abstract of a patent are processed, including: word segmentation, stop word removal, word form restoration, punctuation removal, etc.:

[0131] Tokenization: The process of splitting the patent title and abstract text into individual words or phrases. For Chinese, the `jieba` library can be used; for English, the `nltk` and `spaCy` libraries can be used.

[0132] Stop word removal: Stop words are common words that usually do not contribute practically to the meaning of the text, such as "的" (de) and "是" (shi) in Chinese, and "and" and "the" in English. These words generally do not provide useful information for tasks such as keyword extraction.

[0133] Lemmatization: The process of reducing words to their base or root form. For example, reducing "casting" to "cast". Treating words with different forms but the same meaning as the same word can improve the accuracy of NLP tasks.

[0134] Punctuation removal: Deleting punctuation marks from the text. Punctuation marks usually do not carry useful text information, so they are removed during the preprocessing step.

[0135] Taking the preprocessing steps using the spaCy library in Python as an example, it specifically includes:

[0136] Import necessary libraries: Use the spacy library to process text and import the spacy library via `import spacy`.

[0137] Load the language model: Load a pre-trained English language model ("en_core_web_sm") using `spacy.load("en_core_web_sm")`. This is a small general-purpose model provided by the spacy library, suitable for processing English text.

[0138] Define the preprocessing function: Define a function named `preprocess_text` to preprocess the input text. This function takes a text string as input.

[0139] Convert text to lowercase: Inside the function, first convert the input text to lowercase to ensure consistency during processing.

[0140] Text tokenization: Use the spacy language model to convert the text into a document object `doc` containing multiple tokens. In this step, spacy splits the text into individual words or tokens.

[0141] Removing stop words and punctuation: Use list comprehensions to iterate through each token in the document and remove stop words (such as meaningless words like "of", "is", etc.) and punctuation. For each remaining token, it is also stemmed or lemmatized (i.e., morphological reduction, for example, reducing "running" to "run").

[0142] Returning the processed text: Recombine the remaining tokens into a string and return this preprocessed text.

[0143] Exemplarily, for the input ("This is an example of running a patent text through preprocessing."), it is first converted to lowercase, and stop words and punctuation are removed, finally outputting a result like "example run patent text preprocess".

[0144] Specifically, taking the patent title and abstract as an example: Use natural language processing (NLP) techniques to extract keywords from the patent title and abstract of the patent, and use the TF-IDF algorithm for weight calculation to screen out the most representative keywords;

[0145] Among them, TF-IDF (Term Frequency-Inverse Document Frequency) is a statistical method used to evaluate the importance of a word in a set of documents.

[0146] In an exemplary embodiment of the present disclosure, extracting keywords from the patent title and abstract, and calculating the weight of each keyword specifically includes:

[0147] S332. Traverse the patent and calculate the term frequencies of the patent title and abstract;

[0148] Calculating TF (term frequency): Calculate the frequency of a certain word appearing in the text.

[0149] S333. Calculate the inverse document frequencies of the patent title and abstract;

[0150] Calculating IDF (inverse document frequency): Calculate the rarity of a word appearing in all documents. The higher the IDF, the more discriminative the word is. That is, the rarity of each word in all patent texts;

[0151] S334. Multiply the term frequency and the inverse document frequency to obtain the weight, and screen keywords according to the weight and the preset number of keywords;

[0152] Calculating the TF-IDF value: Multiply TF and IDF to obtain the weight of each word.

[0153] Filtering keywords based on weights and the preset number of keywords means: after calculating the weight of each word, sort them according to the weight values, and select the first few words with the highest weights as the final keywords. For example: if the number of keywords is set to 3, the first three words with the highest weights will be selected as the final keywords.

[0154] Take Python as an example to extract the most representative keywords from a given text collection (such as patent abstracts) using the TF-IDF algorithm and return the preset number of keywords in each text, including:

[0155] Import necessary libraries: Import TfidfVectorizer class which is a part of sklearn.feature_extraction.text module and is used to calculate TF-IDF values.

[0156] Define a keyword extraction function: Define a function called extract_keywords to extract keywords from text data (such as patent abstracts). This function accepts a text list (corpus) and an integer top_n as parameters. top_n represents the number of keywords to be extracted, and the default value is 10.

[0157] Initialize TF-IDF vectorizer: Inside the function, use the TfidfVectorizer class to create a vectorizer vectorizer and set max_features = top_n, which means only extracting the top_n features (i.e. keywords) with the highest TF-IDF values.

[0158] Calculate the TF-IDF matrix: Then, use the fit_transform method of vectorizer to convert the input text list (corpus) into the TF-IDF matrix tfidf_matrix. The TF-IDF value of each document will be represented as a vector.

[0159] Get feature names: Use the vectorizer.get_feature_names_out() method to get the name corresponding to each feature (keyword) and store it in the feature_names list.

[0160] Extract keywords for each document: Initialize an empty list keywords to store the keywords for each document. Then, traverse each document in the TF-IDF matrix, convert the TF-IDF vector of each document into an array, and sort the values ​​in the array. Get the keywords of the document by taking the last top_n indexes of the sorted array (i.e. the indexes of the top_n features with the highest TF-IDF values), and add these keywords to the keywords list.

[0161] Return keyword list: The function returns a keywords list containing the top_n keywords for each document.

[0162] For example, assuming that corpus is a list containing multiple patent abstracts, such as ["Patent text example 1", "Another example of patent text"], calling the extract_keywords(corpus) function will extract the keywords in each abstract and return a list of these keywords.

[0163] Extract the innovativeness of the patent, including:

[0164] S341, converting keywords and technical fields into feature vectors;

[0165] S342. Calculate the similarity between the patent and the historical patent. A low cosine similarity indicates that the technical features of the new patent are different from those of the existing patents and the degree of innovation is high.

[0166] S343. Calculate average similarity by similarity: Calculate the average similarity between the current patent and all historical patents. This average reflects the overall similarity between the new patent and the existing patents.

[0167] S344, calculating the innovation degree by the average similarity;

[0168] The expression of innovation is: innovation = 1-average similarity. From the expression, we can see that the lower the similarity, the higher the innovation, and vice versa.

[0169] Since the development of technology is dynamic, the technical differences and time distance between the current new patent and the early patent will affect the evaluation of innovation. Therefore, when calculating the innovation, the time factor should also be considered, including:

[0170] S351, converting keywords and technical fields into feature vectors;

[0171] S352. Calculate the similarity between the patent and the historical patent. A low cosine similarity indicates that the technical features of the new patent are different from those of the existing patents and the degree of innovation is high.

[0172] S353. Calculate average similarity by similarity; calculate the average similarity between the current patent and all historical patents. This average reflects the overall similarity between the new patent and the existing patents;

[0173] S354. Calculate the time difference between the publication date of the patent and the historical patent;

[0174] The time difference is calculated as: the difference between the announcement date of the current patent and the announcement date of the historical patent.

[0175] S355, calculating the attenuation factor by the time difference;

[0176] The expression for calculating the decay factor is: decay factor = 1 / (1+time difference / 365). Assume that one year (365 days) is the time unit. The decay factor decreases as time increases, that is, the longer the time from the current date, the smaller the decay factor.

[0177] S356, multiplying the similarity by the attenuation factor to obtain the attenuated similarity;

[0178] S357. Calculate the attenuated average similarity through the attenuated similarity.

[0179] Finally, the extracted keywords, identified technical fields, and calculated innovation scores can be displayed to users through data visualization tools. These results can be used in practical scenarios such as patent review, technology research and development decisions, and competitive intelligence analysis.

[0180] Taking the calculation of innovation in Python as an example, it includes:

[0181] Import the necessary libraries:

[0182] Import the cosine_similarity function, which is a function from the sklearn.metrics.pairwise module that calculates the cosine similarity between vectors.

[0183] Define the innovation evaluation function:

[0184] Define a function called evaluate_innovation to evaluate the innovation of a new patent. This function accepts two parameters:

[0185] new_patent_vector: feature vector of new patents.

[0186] historical_patent_vectors: A collection of feature vectors of historical patents.

[0187] Inside the function, the cosine similarity between new_patent_vector and historical_patent_vectors is first calculated. This similarity reflects the degree of similarity between the new patent and the historical patent.

[0188] Calculate average similarity: The function calculates the average avg_similarity of all similarities, which represents the overall similarity between the new patent and the historical patent.

[0189] Calculating Innovation: Innovation is calculated using the formula 1-avg_similarity. The lower the similarity, the higher the innovation, and vice versa. Therefore, innovation is equal to 1 minus the average similarity.

[0190] Exemplary:

[0191] Assuming that new_patent_vector and historical_patent_vectors are vectorized patent features (for example, feature vectors obtained using TF-IDF or other vectorization methods), the innovation score of the new patent can be calculated by calling evaluate_innovation(new_patent_vector, historical_patent_vectors) and stored in the variable innovation_score.

[0192] Time decay weight: Assign higher decay weights to older historical patents, emphasizing the innovativeness of new patents relative to recent patents.

[0193] Define the time decay function:

[0194] Define a function called apply_time_decay to perform time decay on patent similarity. This function receives three parameters:

[0195] similarities: a list or array of patent similarities.

[0196] publication_dates: A list or array of publication dates corresponding to the patents.

[0197] current_date: current date, used to calculate the time difference.

[0198] Initialization list: Inside the function, initialize an empty list decayed_similarities to store the similarity values ​​after time decay.

[0199] Traverse similarities and publication dates: Use the zip function to combine the similarities list and the publication date list publication_dates together, and traverse them one by one. In each traversal, you will get a similarity value sim and the corresponding publication date pub_date.

[0200] Calculate time difference: For each pair of similarity and release date, calculate the time difference time_diff between the release date and the current date in days.

[0201] Calculate the decay factor: Use the time difference to calculate the decay factor decay_factor, the formula is 1 / (1+time_diff / 365), assuming that one year (365 days) is the time unit. This decay factor will decrease as time increases, that is, the longer it is from the current date, the smaller the decay factor.

[0202] Apply decay factor: multiply the original similarity value sim by the decay factor to get the decayed similarity and add the result to the decayed_similarities list.

[0203] Returns a list of decayed similarities: Finally, the function returns a list of decayed_similarities containing all similarity values ​​that have been decayed over time.

[0204] By combining quantitative analysis of patent feature data with machine learning algorithms, accurate predictions can be provided at various stages of the technology life cycle based on patent data. By integrating a large amount of historical data and multiple machine learning models, it not only overcomes the reliance of qualitative analysis on expert experience, but also overcomes the limitations of quantitative analysis in the prediction of emerging technologies. It also adopts a dual feature extraction method based on patent classification numbers and text mining, which makes the feature extraction of patent data more accurate and provides more reliable input data for technology life cycle prediction.

[0205] Reference Figure 2 As shown, based on the same inventive concept, the present disclosure also proposes a technology life cycle prediction system based on patent data, including:

[0206] An acquisition module 110 is used to acquire patents from a patent database;

[0207] The first prediction module 120 is used to extract characteristic data of the patent and input the characteristic data into a plurality of trained prediction models to obtain a plurality of first prediction results;

[0208] The second prediction module 130 is used to fuse multiple first prediction results through a voting mechanism to obtain a second prediction result.

[0209] Reference Figure 3 As shown, based on the same inventive concept, the present disclosure also proposes a device including a memory and a processor, wherein the memory stores computer instructions that can be executed on the processor, and the processor executes the above-mentioned technology lifecycle prediction method based on patent data when running the computer instructions.

[0210] Based on the same inventive concept, the present disclosure also proposes a computer-readable storage medium on which computer instructions are stored. When the computer instructions are executed, the above-mentioned technology life cycle prediction method based on patent data can be implemented.

[0211] Among them, any reference to memory, storage, database or other media used in the embodiments provided by the present invention may include non-volatile and / or volatile memory. Non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory may include random access memory (RAM) or external cache memory.

[0212] It should be noted that, in this article, relational terms such as "first" and "second" are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or elements inherent to such process, method, article or device. In the absence of further restrictions, the elements defined by the sentence "comprise a ..." do not exclude the existence of other identical elements in the process, method, article or device including the elements.

[0213] Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent substitutions for some of the technical features therein; and these modifications or substitutions do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A technology life cycle prediction method based on patent data, characterized in that: include: Obtain characteristic data of patents in patent database; Inputting the characteristic data into a plurality of trained prediction models to obtain a plurality of first prediction results of the technology life cycle; Multiple first prediction results are integrated through a voting mechanism to obtain a second prediction result of the technology life cycle.

2. The method for predicting technology life cycle based on patent data according to claim 1, characterized in that: The obtaining of characteristic data of patents in the patent database includes: Patents in the patent database are obtained through multi-threaded crawler technology, where each thread has a different patent classification number; Extract characteristic data of the patent.

3. The method for predicting technology life cycle based on patent data according to claim 2, characterized in that: Before extracting the characteristic data of the patent, it also includes: preprocessing the patent.

4. The method for predicting technology life cycle based on patent data according to claim 1, characterized in that: Train multiple predictive models, including: Obtaining patent training features and training labels, and constructing a data set based on the training features and training labels; Dividing the data set into a training set and a test set; The prediction model is trained using the training set to obtain a preliminarily trained prediction model, and the preliminarily trained prediction model is tested using the test set to obtain a trained prediction model.

5. The method for predicting technology life cycle based on patent data according to claim 2, characterized in that: The characteristic data includes technical fields; Extracting characteristic data of the patent includes: obtaining the technical field to which the patent belongs through the patent classification number.

6. The method for predicting technology life cycle based on patent data according to claim 5, characterized in that: The technical field to which the patent belongs obtained by the patent classification number includes: Construct a mapping table between patent classification numbers and technical fields; In response to the input of the patent classification number, the patent classification number is obtained, and based on the patent classification number and the mapping table, the technical field to which the patent belongs is obtained.

7. The method for predicting technology life cycle based on patent data according to claim 5, characterized in that: The characteristic data includes keywords of patent titles and abstracts; Extract characteristic data of the patent, including: Traverse the patents and calculate the word frequencies of the patent titles and abstracts of the patents; Calculate the inverse document frequency of the patent title and abstract; The weight is obtained by multiplying the word frequency and the inverse document frequency, and keywords are filtered according to the weight and a preset number of keywords.

8. The method for predicting technology life cycle based on patent data according to claim 7, characterized in that: The characteristic data include innovation degree; Extract characteristic data of the patent, including: Convert the keywords and technical fields into feature vectors; Calculate the similarity between the patent and historical patents; Calculate the average similarity through the similarities; The novelty is calculated by the average similarity.

9. The method for predicting technology life cycle based on patent data according to claim 7, characterized in that: The characteristic data include innovation degree; Extract characteristic data of the patent, including: Convert the keywords and technical fields into feature vectors; Calculate the similarity between the patent in question and historical patents: Calculate the time difference between the publication date of the patent and the historical patent; Calculating a decay factor using the time difference; Multiplying the similarity by an attenuation factor to obtain an attenuated similarity; Calculating the attenuated average similarity through the attenuated similarity; The innovation degree is calculated by the average similarity after attenuation.

10. A technology life cycle prediction system based on patent data, characterized in that: include: An acquisition module, used to acquire characteristic data of patents in a patent database; A first prediction module, used for inputting the characteristic data into a plurality of trained prediction models to obtain a plurality of first prediction results of the technology life cycle; The second prediction module is used to fuse multiple first prediction results through a voting mechanism to obtain a second prediction result of the technology life cycle.

Images