Patent data analysis program and method

Abstract

This document provides a method for analyzing and processing patent data. [Solution] A patent data analysis program that causes a computer to perform the following steps: a data aggregation step of acquiring patent data having multiple information items and generating statistical data based on the information items; a step of sending a first prompt to a language model that includes a natural language question received from a user and statistical data, and obtaining a quantitative analysis result in structured data format that includes a combination of analysis axes related to the first question as a filtering condition; a data extraction step of extracting related patent data from the patent data using the filtering condition included in the quantitative analysis result; a step of sending a second prompt to a language model that includes a natural language question received from a user and the extracted related patent data, and obtaining a qualitative analysis result that analyzes the content of the related patent data; and an output step of outputting the quantitative analysis result and the qualitative analysis result.

Description

Technical Field

[0001] The present invention relates to a patent data analysis program and method.

Background Art

[0002] Conventionally, techniques for analyzing patent information have been known in order to evaluate a company's competitiveness or formulate a research and development strategy. For example, Patent Document 1 discloses an apparatus that aggregates and analyzes the number of characters in claims and the number of applications per applicant to evaluate a company's patent strategy.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] However, although the technique described in Patent Document 1 is useful in creating quantitative aggregated data of patent information, the process of interpreting the meaning contained in the statistical data, such as changes in technology trends and strategic intentions of competing companies, and deriving specific insights still requires an analyst with a high level of expertise to perform. Therefore, there has been a problem that patent analysis requires a great deal of time and effort.

[0005] In addition, it has been difficult to automatically identify relevant patent groups and provide consistent analysis results that delve into the technical content for complex natural language questions that combine quantitative and qualitative aspects, such as "which companies have been increasing their applications in the field of AI technology in recent years, and what are the technical characteristics of those companies."

[0006] This invention was made to solve these conventional problems, and aims to provide accurate and in-depth analytical results in response to users' natural language questions by seamlessly linking quantitative and qualitative analysis of patent data. [Means for solving the problem]

[0007] This patent data analysis program causes a computer to perform the following steps: a data aggregation step of acquiring patent data having multiple information items and generating statistical data based on the information items; a step of sending a first prompt to a language model that includes a natural language question received from a user and statistical data, and obtaining quantitative analysis results in structured data format that include a combination of analysis axes related to the first question as a filtering condition; a data extraction step of extracting relevant patent data from the patent data using the filtering conditions included in the quantitative analysis results; a step of sending a second prompt to the language model that includes a natural language question received from a user and the extracted relevant patent data, and obtaining qualitative analysis results that analyze the content of the relevant patent data; and an output step of outputting the quantitative analysis results and the qualitative analysis results.

[0008] This patent data analysis method involves a computer performing the following steps: a data aggregation step in which it acquires patent data having multiple information items and generates statistical data based on the information items; a step in which it sends a first prompt to a language model that includes a natural language question received from a user and statistical data, and obtains quantitative analysis results in structured data format that include a combination of analysis axes related to the first question as a filtering condition; a data extraction step in which it extracts relevant patent data from the patent data using the filtering condition included in the quantitative analysis results; a step in which it sends a second prompt to a language model that includes a natural language question received from a user and the extracted relevant patent data, and obtains qualitative analysis results that analyze the content of the relevant patent data; and an output step in which it outputs the quantitative analysis results and the qualitative analysis results. [Effects of the Invention]

[0009] According to the present invention, it is possible to automatically extract highly relevant analytical axes from the quantitative aggregation results of patent data, and to consistently provide qualitative insights from a deep analysis of the extracted patent group. This significantly reduces the specialized knowledge and man-hours required for patent analysis, and enables interactive and efficient analysis based on the user's questions in natural language. [Brief explanation of the drawing]

[0010] [Figure 1] System schematic diagram [Figure 2] Block diagram of the terminal [Figure 3] Process flowchart [Modes for carrying out the invention]

[0011] The embodiments will be described in detail below with reference to the figures.

[0012] Figure 1 is a schematic diagram of a system for performing patent data analysis. To perform patent data analysis, terminal 1 connects to a natural language processing (generative AI) server 2 via a network.

[0013] The natural language processing server 2 is a computer incorporating a language model that performs inference, analysis, and text generation based on input data containing natural language. The language model referred to in this embodiment includes not only large-scale language models (LLMs) but also small-scale language models (SLMs). In this embodiment, the OpenAI GPT-4o-mini model is used as an example, but the embodiment is not limited to this, and other language models that provide similar functionality (for example, Google's Gemini or Anthropic's Claude) may be used.

[0014] Furthermore, in the embodiment, in addition to a configuration in which processing by the language model is performed on an external natural language processing server 2 (server-based model), a configuration in which it is performed within terminal 1 without using a cloud service (local model) is also possible. For example, when using a language model that can be executed on terminal 1 in a local environment (a so-called local LLM), the natural language processing server 2 is not required.

[0015] Figure 2 is a block diagram of terminal 1 in a system for executing the patented data analysis processing method of the embodiment. The terminal is, for example, a personal computer, tablet, or smartphone owned by the user.

[0016] Terminal 1 is connected via a system bus 108 to a CPU (Central Processing Unit) 101, ROM (Read Only Memory) 102, RAM (Random Access Memory) 103, HDD (Hard Disk Drive) 105, external I / F (Interface) 106, and an input unit 107. The CPU 101, ROM 102, and RAM 103 constitute a control unit 104.

[0017] ROM102 stores programs and thresholds to be executed by CPU101 in advance. RAM103 has various memory areas, such as an area for deploying programs executed by CPU101 and a work area that serves as a workspace for data processing by the program.

[0018] HDD105 stores the OS, the patent data analysis program for the embodiment, and the patent data to be analyzed. External I / F106 is an interface for communicating with external devices, such as an external server (PC).

[0019] External I / F106 can be any interface that communicates data with an external device. For example, it could be a device that connects locally to the external device (such as a USB memory stick), or it could be a network interface for communication via a wired or wireless network.

[0020] The control unit 104 exchanges data with an external device (natural language processing server) via the external I / F 106 to transmit numerical analysis text data and receive analysis result text and the like.

[0021] The external I / F 106 is connected to a display device (not shown) such as a liquid crystal display. The input unit 107 is an input device such as a keyboard, a mouse, and a scanner (reading device).

[0022] The processing procedure of the patent data analysis program / method according to the embodiment will be described. FIG. 3 is a flowchart of the patent data analysis process according to the embodiment. This flow includes steps of reading patent data (S101), aggregating (S102), quantitatively analyzing using a language model (S103), extracting related patents (S104), qualitatively analyzing the extracted patents using a language model (S105), and outputting the final result (S106). Here, quantitative analysis (also referred to as quantitative analysis or statistical analysis) refers to an analysis method that statistically (numerically) processes numerical data such as the trend of the number of applications and the share by company to grasp objective trends and patterns. On the other hand, qualitative analysis (also referred to as qualitative analysis or content analysis) refers to an analysis method that mainly interprets the content of text data such as the abstract and claims of patent documents to deeply explore qualitative aspects such as technical features, the meaning of the invention, and strategic intentions to gain insights.

[0023] (Step S101: Data reading process) The control unit 104 acquires patent data in a table format such as Excel stored in the HDD 105. This patent data includes at least bibliographic information items such as application number, application date, applicant, patent classification, invention name, and abstract. Note that the data format is not limited to the table format.

[0024] Furthermore, classifications assigned by the company or specific technical items extracted from the text of the specification may be added. In this embodiment, the data is converted into a data frame format using the read_excel function of the Pandas library, the "filing date" column is converted into date type data using the to_datetime function, and then year information is extracted and a new "filing year" column is added.

[0025] (Step S102: Data aggregation processing) Next, the control unit 104 uses the groupby method to perform cross-tabulation on the data frame read in step S101, using one or more of the following as analysis axes: "patent classification," "filing year," and "applicant," to generate statistical data such as the number of applications for each combination. For example, this includes summary tables that compile the number of applications for each specific patent classification (e.g., G06F), filing year, and applicant, as well as values ​​obtained by statistical methods such as calculating the compound annual growth rate (CAGR), moving average, and concentration index (HHI). Note that the items used as analysis axes are not limited to these, and any items included in the patent data can be used, such as classifications assigned by the company or specific technical items described in the specification (e.g., modes for carrying out the invention, effects of the invention).

[0026] (Step S103: Quantitative analysis process) Next, the control unit 104 receives a first question in natural language from the user via the input unit 107 and generates a first prompt for the language model. This first prompt includes at least a string obtained by converting the statistical data generated in step S102 into text format and the string of the first question.

[0027] Furthermore, the prompt can include instructions for outputting the language model's response in a specific structured data format (e.g., JSON, XML, Markdown, etc.) and instructions specifying items to be included in the response (e.g., "analysis results," "relevant patent classifications," etc.). The generated first prompt is sent to the natural language processing server 2 via the external I / F 106.

[0028] The language model identifies the combination of analysis axes most relevant to the question based on the statistical data contained in the first prompt and the first question, and returns the result as a string in the specified structured data format. The control unit 104 obtains this string as the quantitative analysis result.

[0029] (Step S104: Related patent extraction process) Next, the control unit 104 analyzes the quantitative analysis results obtained in step S103 (in this embodiment, a string in JSON format; XML, Markdown, etc. may also be used) and extracts information that serves as filtering criteria, such as "relevant patent classification," "relevant filing year," and "relevant applicant." Then, using these filtering criteria, it filters the data frame containing the original patent data to include only the relevant patent data that matches the criteria. At this time, it also extracts text items that describe the technical content, such as the abstract, claims, and specification text, which will be necessary for the subsequent qualitative analysis.

[0030] (Step S105: Qualitative analysis process) Subsequently, the control unit 104 receives a second question regarding qualitative analysis from the user via the input unit 107 and generates a second prompt for the language model. The first and second questions may be input as a single integrated question, depending on the user's intent.

[0031] This second prompt includes, at a minimum, a string of the relevant patent data extracted in step S104 (e.g., the title and abstract of the invention) converted into text format, and the string of the second question (or combined question). Furthermore, the prompt may include information that specifically indicates the perspective of analysis (e.g., "technical features and trends," "significant inventions," etc.).

[0032] The generated second prompt is sent to the natural language processing server 2. Based on the relevant patent data and the second question contained in the second prompt, the language model interprets the individual patent content and generates and returns a detailed analysis text in natural language as a string, aligned with the indicated perspective. The control unit 104 obtains this string as the qualitative analysis result.

[0033] (Step S106: Output processing) Finally, the control unit 104 integrates the quantitative analysis results obtained in step S103 and the qualitative analysis results obtained in step S105 into a single analysis report, or outputs them as separate reports, in the form of a text file (analysis_report.txt) or other electronic document format (e.g., PDF or Word). In addition, the related patent data extracted in step S104 is also saved separately as a JSON file (extracted_patents.json). [Examples]

[0034] The following shows a patent data analysis program implemented using Python® as a specific embodiment of the present invention. For ease of explanation, it will be explained in multiple code blocks. The execution unit of the program below is the control unit 104, as described in the embodiment. Note that the present invention is not limited to this embodiment.

[0035] (Block 1: Initial setup and library import) This block installs and imports the libraries necessary for running the patent data analysis system. First, it installs the OpenAI library to enable communication with the GPT-4o-mini model. This library provides the functionality to send questions and aggregated data to the LLM via API and obtain advanced analysis results.

[0036] Next, install the Pandas library. Pandas serves as a core tool for reading patent data from Excel files, efficiently manipulating data with dataframes, and performing multidimensional aggregation.

[0037] Next, install the Openpyxl library. This library provides functionality for reading and writing Excel format (.xlsx) files and acts as the backend for Pandas' Excel processing. After these installations, import the necessary modules to enable data processing, API communication, date processing, and file manipulation functions.

[0038] (Code block 1) # Installing necessary libraries !pip install openai pandas openpyxl import pandas as pd import json from openai import OpenAI from datetime import datetime import os # OpenAI API key settings # Use Colab's secrets feature or configure it directly. # from google.colab import userdata # api_key = userdata.get('OPENAI_API_KEY') api_key = "YOUR_OPENAI_API_KEY" # Set your API key here client = OpenAI(api_key=api_key)

[0039] (Block 2: Patent data loading process (S101)) This block provides functionality to read patent data provided in Excel file format and preprocess it into a format suitable for analysis. During data reading, the pd.read_excel() function is used to convert the Excel-formatted patent data into a data frame format. This process reads all column data at once and loads it into memory.

[0040] The date data conversion process converts the application date column from a string type to a date type (datetime). By specifying the `errors='coerce'` parameter, invalid date data is treated as NaT (Not a Time), ensuring system robustness. Furthermore, the application year is extracted. The year portion is extracted from the date-type application date and added as a new column, enabling yearly aggregation.

[0041] Finally, the processing status is visualized by displaying the number of patents loaded, and the data structure can be verified by displaying a list of column names in the data frame. In the expected data structure, the application number represents the patent application number, the application date indicates the date the application was filed, the applicant is the name of the company or individual that filed the application, the patent classification is the IPC classification code (FI or F-term may also be used), the invention title is the title of the invention, and the abstract is a summary of the invention's content. As mentioned above, internal classifications are also possible.

[0042] [Example Output] Loading patent data... Loading complete: 1250 patent data entries Column: ['Application Number', 'Filing Date', 'Applicant', 'Patent Classification', 'Title of Invention', 'Abstract', 'Filing Year']

[0043] (Code Block 2) def load_patent_data(file_path): """ Import patent data from an Excel file. Args: file_path (str): Path to the Excel file Returns: pd.DataFrame: A data frame containing patent data. """ print("Loading patent data...") df = pd.read_excel(file_path) # Convert the application date to a date type df['Application Date'] = pd.to_datetime(df['Application Date'], errors='coerce') df['Application Year'] = df['Application Date'].dt.year print(f"Loading complete: {len(df)} patent data items") print(f"columns: {df.columns.tolist()}") return df

[0044] (Block 3: Patent data aggregation processing (S102)) This block aggregates the loaded patent data along three axes: patent classification (IPC), filing year, and applicant, and generates statistical data necessary for quantitative analysis. In the three-axis cross-tabulation, the groupby() method is used to group the data according to each combination of patent classification, filing year, and applicant.

[0045] By counting the number of applications for each group, detailed summary tables are generated, making it possible to understand the annual trends of companies in specific technological fields. The patent classification-based summary calculates the total number of applications for each IPC classification. This provides basic data for understanding the overall application scale in technological fields. The applicant-based summary calculates the total number of applications for each company and individual. This summary makes it possible to quantitatively evaluate the scale of an applicant's activity.

[0046] The year-by-year aggregation calculates the total number of applications for each year, allowing for an understanding of application trends over time. The function returns a dictionary-type data. This dictionary contains detailed data for the 3-axis cross-tabulation under the 'detail' key, totals by IPC classification under the 'by_ipc' key, totals by applicant under the 'by_applicant' key, and totals by application year under the 'by_year' key. Multidimensional aggregation provides a technical benefit by offering LLM a foundation for analyzing data from multiple perspectives.

[0047] [Example Output] Compiling patent data... Aggregation complete: 156 aggregated data entries [Example of aggregated results] Summary by patent classification, filing year, and applicant: Patent Classification | Year of Application | Applicant | Number of Applications G06N 2021 A Corporation 15 G06N 2021 B Co., Ltd. 8 G06N 2022 A Co., Ltd. 23 G06N 2022 B Co., Ltd. 12 G06F 2021 C Corporation 10 ... Total by patent classification: Patent Classification Total Number of Applications G06N 180 G06F 145 H04L 220 ... Total by applicant: Applicant Total number of applications Company A 156 B 98 Co., Ltd. C87 Co., Ltd. ... Total by year of application: Year of application Total number of applications 2020 234 2021 312 2022 398 2023 306

[0048] (Code block 3) def aggregate_patent_data(df): """ Patent data is compiled by patent classification (IPC), filing year, and applicant. Args: df (pd.DataFrame): Patent Data Returns: dict: A dictionary containing various aggregated results. """ print("\nCollecting patent data...") # Aggregated by patent classification x filing year x applicant aggregated = df.groupby(['Patent Classification', 'Application Year', 'Applicant']).agg({ 'Application Number': 'count'}).reset_index() aggregated.columns = ['Patent Classification', 'Year of Application', 'Applicant', 'Number of Applications'] # Total by patent classification ipc_total = df.groupby('Patent classification').agg({ 'Application number': 'count'}).reset_index() ipc_total.columns = ['Patent Classification', 'Total Number of Applications'] # Total by applicant applicant_total = df.groupby('Applicant').agg({ 'Application Number': 'count'}).reset_index() applicant_total.columns = ['Applicant', 'Total number of applications'] # Total by year of application year_total = df.groupby('Application Year').agg({ 'Application Number': 'count'}).reset_index() year_total.columns = ['Year of application', 'Total number of applications'] print(f"Aggregation complete: {len(aggregated)} aggregated data items") return { 'detail': aggregated, 'by_ipc': ipc_total, 'by_applicant': applicant_total, 'by_year': year_total }

[0049] (Block 4: Quantitative Analysis Processing (S103)) This block sends aggregated patent data and user questions to GPT-4o-mini for quantitative analysis. LLM analyzes statistical trends and automatically extracts three pieces of information relevant to the question: IPC (Information Program Category), filing year, and applicant.

[0050] The first step in processing is data formatting. By converting the aggregated data into text format using the to_string() method, the data frame is transformed into tabular text that LLM can understand.

[0051] Next, we construct the prompt. We generate a detailed prompt that includes aggregated results and user questions, explicitly specifying that the output should be in JSON format. We also define the three items to be extracted: IPC, year, and applicant. Note that the prompt design is not limited to this; questions may be included to obtain the desired output.

[0052] For API communication, we will use the OpenAI Chat Completions API. We will specify "gpt-4o-mini" as the model and force responses to be in JSON format by setting the response_format parameter to {"type": "json_object"}. The temperature parameter will be set to 0.3 to ensure consistent analysis results are generated.

[0053] In the results analysis, the JSON response from the LLM is parsed to obtain three extracted axes: IPC, year, and applicant. The analysis results and the reasons for extraction are also obtained to ensure the transparency of the analysis.

[0054] A key technical feature of this block is that, thanks to LLM's natural language understanding capabilities, it can extract appropriate analytical axes even from ambiguous user questions. Furthermore, it can understand trends in statistical data and identify the patent groups most relevant to the question.

[0055] [Example Output] Quantitative analysis is in progress... Quantitative analysis completed Related patent classifications (IPC): ['G06N', 'G06F'] Related application years: [2021, 2022, 2023] Related applicants: ['Company A', 'Company B'] [Quantitative analysis results] { "Analysis Results": "In the fields of AI technology (G06N) and computational processing technology (G06F), both Company A and Company B showed a significant increase in patent applications from 2021 to 2023. In particular, both companies saw a sharp increase in the number of applications in 2022, with Company A recording 23 applications, a 53% increase year-on-year, and Company B recording 12 applications, a 50% increase. This trend is thought to reflect the strengthening of intellectual property strategies accompanying the acceleration of the practical application of deep learning technology." "Related patent classifications": ["G06N", "G06F"], "Related application years": [2021, 2022, 2023] "Related applicants": ["Company A", "Company B"], "Reason for extraction": "We extracted G06N (Computational Models) and G06F (Electrical Digital Data Processing), which are relevant to the AI ​​technology field mentioned in the question. We selected the period 2021-2023, when patent applications surged, and extracted the top two companies that were most actively filing applications during this period." }

[0056] (Code block 4) def quantitative_analysis(aggregated_data, user_question): """ The aggregated results and user questions were input into LLM for quantitative analysis. Extract relevant patent classifications (IPC), filing year, and applicant. Args: aggregated_data (dict): aggregated data user_question (str): User's question Returns: dict: Analysis results and three extracted axes """ print("\nQuantitative analysis in progress...") # Convert aggregated data to text format detail_text = aggregated_data['detail'].to_string(index=False) ipc_text = aggregated_data['by_ipc'].to_string(index=False) applicant_text = aggregated_data['by_applicant'].to_string(index=False) year_text = aggregated_data['by_year'].to_string(index=False) prompt = f""" The following is a summary of patent data. Quantitative analysis was performed based on user questions. Please extract the following three pieces of information: the relevant patent classification (IPC), the year of application, and the applicant. [Summary by patent classification, filing year, and applicant] {detail_text} [Total by Patent Classification (IPC)] {ipc_text} [Total by applicant] {applicant_text} [Total by year of application] {year_text} [User Questions] {user_question} Please answer in JSON format in the following format: {{ "Analysis Results": "Results of quantitative analysis (trends, characteristics, statistical insights)", "Related patent classifications": ["H04L", "G06F", ...], "Related application year": [2020, 2021, ...] "Related applicants": ["Company A", "Company B", ...], "Reason for extraction": "An explanation of why these patent classifications, years, and applicants were selected." }} """ response = client.chat.completions.create( model="gpt-4o-mini" Messages=[ {"role": "system", "content": "You are a patent data analysis expert. Perform quantitative analysis and return the results in accurate JSON format."}, {"role": "user", "content": prompt} ], response_format={"type": "json_object"}, Temperature = 0.3 ) result = json.loads(response.choices[0].message.content) print("Quantitative analysis complete") print(f"Related Patent Classification (IPC): {result.get('Related Patent Classification', [])}") print(f"Related application year: {result.get('Related application year', [])}") print(f"Related applicants: {result.get('Related applicants', [])}") return result

[0057] (Block 5: Extraction of related patents and JSON processing (S104)) This block extracts relevant patent applications from the original patent data based on three conditions (patent classification, filing year, and applicant) extracted through quantitative analysis, and generates JSON format data for qualitative analysis. The extracted data should include not only bibliographic information but also text data such as abstracts, claims, and specification text (any items within them) necessary for the language model to analyze the technical content. First, the extraction conditions are obtained. Three lists, namely IPC, year, and applicant, are obtained from the quantitative analysis results. These are the conditions that the LLM determined to be relevant to the question.

[0058] In multi-condition filtering, the isin() method is used to extract records that meet each condition. By applying the AND condition (& operator), only patents that match all three conditions are extracted, narrowing the list down to the patents most relevant to the question. In the data type conversion process, the to_dict('records') method is used to convert the data frame into a list of JSON-compatible dictionaries. This conversion results in each patent being represented as a single dictionary object.

[0059] In processing date data, Timestamp type data is converted to an ISO 8601 format string. NaN values ​​are converted to None, and the representation in JSON format is optimized to ensure successful serialization with JSON.dumps(). The technical significance of this block is that by filtering to extract only the subset relevant to the question from all patent data, the context length of the LLM in the subsequent qualitative analysis can be optimized, thereby improving the accuracy of the analysis.

[0060] [Example Output] Extracting related patents... Extraction complete: 23 patents - Patent classification (IPC): ['G06N', 'G06F'] - Application year: [2021, 2022, 2023] - Applicants: ['Company A', 'Company B'] The extracted patent data has been saved to 'extracted_patents.json'. [Example JSON Output] (Two examples are shown as output examples.) [ { Application number: JP2021-123456 "Application Date": "2021-06-15T00:00:00", "Year of application": 2021, "Applicant": "A Corporation", "Patent Classification": "G06N", "Title of Invention": "Image Recognition System Using Deep Learning" Summary: "Utilizing convolutional neural networks..." }, { Application number: JP2022-234567 "Application Date": "2022-03-20T00:00:00", "Year of application": 2022, "Applicant": "B Co., Ltd." "Patent Classification": "G06F", "Title of Invention": "Machine Learning Acceleration Device Using Distributed Processing" "Summary": "By using parallel processing with multiple GPUs..." } ]

[0061] (Code block 5) def extract_relevant_patents(df, analysis_result): """ Based on the patent classification (IPC), filing year, and applicant extracted by LLM, Extract relevant patent applications Args: df (pd.DataFrame): Original patent data analysis_result (dict): Quantitative analysis result Returns: List: List of patent data in JSON format """ print("\nExtracting related patents...") target_ipcs = analysis_result.get('Related Patent Classifications', []) target_years = analysis_result.get('Relevant Filing Years', []) target_applicants = analysis_result.get('Related Applicants', []) # Filtering (extracting patents that meet all three conditions) filtered_df = df[ (df['Patent Classification'].isin(target_ipcs)) & (df['Application Year'].isin(target_years)) & (df['Applicant'].isin(target_applicants)) ] print(f"Extraction completed: {len(filtered_df)} patents") print(f" - Patent classification (IPC): {target_ipcs}") print(f" - Application Year: {target_years}") print(f" - Applicants: {target_applicants}") # JSONization patents_json = filtered_df.to_dict('records') # Convert date type to ISO format string for patent in patents_json: for key, value in patent.items(): if isinstance(value, pd.Timestamp): patent[key] = value.isoformat() elif pd.isna(value): patent[key] = None return pulses_json

[0062] (Block 6: Qualitative Analysis Processing (S105)) This block sends extracted and JSON-formatted patent data and user questions to GPT-4o-mini for qualitative analysis of patent content. LLM understands the technical content of each patent and evaluates trends and innovativeness.

[0063] In controlling the amount of data, if there are many patents (e.g., more than 50), only the first 50 will be analyzed. This ensures compliance with API token limits and optimizes processing costs. For large amounts of data, a warning message will be displayed to inform the user of the processing status. In the JSON formatting process, the json.dumps() function is used to convert patent data into an easy-to-read, indented JSON string. Specifying the ensure_ascii=False parameter ensures that Japanese characters are represented correctly.

[0064] In prompt design, a detailed prompt is constructed that includes patent data and user questions. Five analytical perspectives are clearly defined: firstly, technical features and trends; secondly, significant inventions and innovative aspects; thirdly, the applicant's strategy and direction; fourthly, development trends in the technical field; and fifthly, specific answers to the questions. Note that prompt design is not limited to these; questions may be included to obtain the desired output.

[0065] For API communication, the "gpt-4o-mini" model is used. Setting the temperature parameter to 0.5 generates an analysis with a moderate level of creativity. The max_tokens parameter is set to 2000 to ensure a sufficiently detailed response. The technical effect of this block is that the natural language generation capabilities of the LLM make it possible to extract meaningful insights from specialized technical documents such as patent specifications and present them in a human-readable format.

[0066] [Example Output] Performing qualitative analysis... Qualitative analysis completed [Qualitative analysis results] 1. Technical characteristics and trends Analysis of the 23 extracted patents revealed the following technical characteristics: The diversification of deep learning architectures is remarkable, with multiple approaches being developed in parallel, including convolutional neural networks (CNNs), recurrent neural networks (RNNs), and Transformer-based models. In particular, since 2022, there has been a surge in inventions utilizing attention mechanisms, and a wide range of applications are being seen, from natural language processing to image recognition. Furthermore, there is an increasing trend in patent applications related to lightweight technologies (quantization, pruning, knowledge distillation) intended for inference on edge devices, indicating that technological development is progressing with practical applications in mind. 2. Important inventions or innovative content Three particularly noteworthy inventions are listed below: (1) JP2028-234567 "Machine Learning Acceleration Device using Distributed Processing" (B Corporation) By utilizing a dynamic load balancing algorithm across multiple GPUs, we have achieved a training speed 3.5 times faster than conventional methods. This technology significantly contributes to improving the efficiency of training large-scale models. (2) JP2028-345678 "High-precision learning system with small amounts of data" (A Corporation) By combining few-shot learning and meta-learning, we achieve equivalent accuracy with one-tenth the amount of data compared to conventional methods, offering an innovative approach to reducing data acquisition costs. (3) JP2028-456789 "Explainable AI Inference Device" (A Corporation) This technology visualizes the reasoning behind decisions made by deep learning models, which tend to be black boxes. It enables practical applications in fields requiring high reliability, such as healthcare and finance. 3. Applicant's strategy and direction Company A employs a comprehensive intellectual property portfolio strategy that broadly covers everything from foundational technologies to application layers. In particular, its patent applications focus on solving challenges in social implementation, such as explainable AI and privacy-preserving learning. On the other hand, Company B is pursuing a strategy focused on improving computational efficiency and scaling up, and it is believed that they are promoting technological development with a view to providing cloud-based AI services. 4. Development Trends in Technology Fields The following development trends can be observed across the entire AI technology field: • Shift from performance-driven approaches to practical applications (edge ​​AI, lightweight design) • Growing attention to reliability and explainability • Advances in multimodal learning (integrated processing of images, text, and audio) • Increasing importance of privacy protection technologies (federated learning, differential privacy) 5. Specific answers to user questions To summarize the "technological innovation of the extracted patents," what makes them innovative is that they offer concrete solutions to practical challenges in the social implementation of AI technology (computational costs, data shortages, accountability, and privacy), rather than simply improving performance. In particular, elements such as learning with small amounts of data, ensuring explainability, and execution on edge devices can be considered important inventions that directly contribute to the democratization and widespread adoption of AI technology.

[0067] (Code block 6) def qualitative_analysis(patents_json, user_question): """ The extracted patent JSON data and user questions are input into LLM. Conduct a qualitative analysis. Args: patents_json (list): Patent data in JSON format user_question (str): User's question Returns: str: Qualitative analysis result text """ print("\nQualitative analysis in progress...") # If there is a large amount of patent data, abstraction or limit on the number of patents may be required. max_patents = 50 # Maximum number of patents to analyze at once if len(patents_json) > max_patents: print(f"Warning: Because the number of patents is large ({len(patents_json)}), only the first {max_patents} will be analyzed.") patents_to_analyze = patents_json[:max_patents] else: patents_to_analyze = patents_json # Convert JSON to a string (format for readability) patents_text = json.dumps(patents_to_analyze, ensure_ascii=False, indent=2) prompt = f""" The following is extracted patent application data. Please perform a qualitative analysis based on the user's questions. [Extracted patent data (JSON format)] {patents_text} [User Questions] {user_question} Analyze the patent in detail and answer from the following perspectives: 1. Technical characteristics and trends 2. Important inventions or innovative content 3. Applicant's strategy and direction 4. Development Trends in Technology Fields 5. Specific answers to user questions """ response = client.chat.completions.create( model="gpt-4o-mini" Messages=[ {"role": "system", "content": "You are a patent content analysis expert. Provide technical insights and strategic perspectives."} {"role": "user", "content": prompt} ], temperature=0.5, max_tokens=2000 ) result = response.choices[0].message.content print("Qualitative analysis complete") return result

[0068] (Block 7: Main processing flow integration and output (S107)) This block integrates the above processing blocks and executes the entire patent data analysis flow. It functions as a user interface, enabling an interactive analysis process.

[0069] At the start of processing, the file upload function is used. An Excel file is uploaded via the browser using Google Colab's files.upload() function. The uploaded file name is automatically retrieved.

[0070] In the data loading step, patent data is loaded by calling the load_patent_data() function defined in Block 2, and preprocessing such as extracting the filing year is performed. In the data aggregation step, three-axis aggregation is performed using the aggregate_patent_data() function defined in Block 3, and statistical data for quantitative analysis is generated.

[0071] In the input of the first question, the input() function is used to obtain a question from the user for quantitative analysis. For example, a question such as "Which companies are seeing an increase in patent applications due to AI technology?" is expected. For the execution of the quantitative analysis, the quantitative_analysis() function defined in Block 4 is used to perform the analysis in LLM. Relevant IPCs, years, and applicants are automatically extracted, and the results are displayed in JSON format.

[0072] In the patent extraction step, the relevant patents are extracted using the extract_relevant_patents() function defined in Block 5 and saved to a file in JSON format. For the input of the second question, the input() function is used to obtain a question from the user for qualitative analysis. For example, a question such as "What is the technological innovation of the extracted patents?" is expected.

[0073] In the qualitative analysis, the LLM performs content analysis using the `qualitative_analysis()` function defined in Block 6. This provides technical insights and strategic perspectives. For saving and downloading the results, the extracted patent data is saved to the `extracted_patents.json` file, and the full analysis report is saved to the `analysis_report.txt` file. These files are automatically downloaded to the local environment using the `files.download()` function.

[0074] The technical significance of this workflow lies in its ability to automatically extract patents relevant to a question from a large amount of patent data, enabling comprehensive analysis from both quantitative and qualitative perspectives. This significantly reduces the amount of human analysis required while providing advanced insights that leverage the expertise of LLM professionals.

[0075] (Code block 7) def main(): """ Main processing flow for patent data analysis """ print("=" * 60) print("Patent Data Quantitative and Qualitative Analysis System") print("=" * 60) # Uploading files (Google Colab) from google.colab import files print("\nPlease upload the Excel file containing your patent data...") uploaded = files.upload() # Get the uploaded file name file_name = list(uploaded.keys())[0] # 1. Data Loading df = load_patent_data(file_name) # 2. Aggregation aggregated_data = aggregate_patent_data(df) #3. User Question (Part 1) - For Quantitative Analysis print("\n" + "=" * 60) question1 = input("Quantitative analysis of question (part 1): ") # 4. Performing quantitative analysis analysis_result = quantitative_analysis(aggregated_data, question1) print("\n[Quantitative analysis results]") print(json.dumps(analysis_result, ensure_ascii=False, indent=2)) # 5. Extraction of related patents patents_json = extract_relevant_patents(df, analysis_result) # Save the extraction results with open('extracted_patents.json', 'w', encoding='utf-8') as f: json.dump(patents_json, f, ensure_ascii=False, indent=2) print(f"\nThe extracted patent data has been saved to 'extracted_patents.json'") # 6. User Questions (Part 2) - For Qualitative Analysis print("\n" + "=" * 60) question2 = input("Question (Part 2) Qualitative Analysis: ") # 7. Performing qualitative analysis qualitative_result = qualitative_analysis(patents_json, question2) print("\n" + "=" * 60) print("[Qualitative analysis results]") print("=" * 60) print(qualitative_result) # Save the results with open('analysis_report.txt', 'w', encoding='utf-8') as f: f.write("Patent Data Analysis Report\n") f.write("=" * 60 + "\n\n") f.write(f"Question 1 (Quantitative Analysis): {question1}\n\n") f.write("[Quantitative analysis results]\n") f.write(json.dumps(analysis_result, ensure_ascii=False, indent=2)) f.write("\n\n" + "=" * 60 + "\n\n") f.write(f"Question 2 (Qualitative Analysis): {question2}\n\n") f.write("[Qualitative analysis results]\n") f.write(qualitative_result) print("\nThe analysis report has been saved to 'analysis_report.txt'") # Download file files.download('extracted_patents.json') files.download('analysis_report.txt') # execution if __name__ == "__main__": main()

[0076] Although embodiments have been described above, these embodiments are presented as examples and are not intended to limit the scope of the invention. This novel embodiment can be implemented in various other forms, and various omissions, substitutions, and modifications can be made without departing from the spirit of the invention. This embodiment and its variations are included in the scope and spirit of the invention, as well as in the claims of the invention and its equivalents. [Explanation of Symbols]

[0077] 101 CPU, 102 ROM, 103 RAM, 104 Control Unit, 105 HDD, 106 External I / F, 107 Input Unit, 108 System Bus

Claims

1. On the computer, A data aggregation step involves acquiring patent data having multiple information items and generating statistical data based on those information items. The steps include: sending a first prompt to a language model, which includes a natural language question received from a user and the statistical data; and obtaining a quantitative analysis result in structured data format from the language model, which includes a combination of analysis axes related to the first question as a filtering condition; A data extraction step in which relevant patent data is extracted from the patent data using the filtering conditions included in the quantitative analysis results, The steps include sending a second prompt to the language model, which includes a natural language question received from the user and the extracted related patent data, and obtaining a qualitative analysis result from the language model by analyzing the content of the related patent data, An output step that outputs the quantitative analysis results and the qualitative analysis results, A patent data analysis program that performs this operation.

2. Computers A data aggregation step involves acquiring patent data having multiple information items and generating statistical data based on those information items. The steps include: sending a first prompt to a language model, which includes a natural language question received from a user and the statistical data; and obtaining a quantitative analysis result in structured data format from the language model, which includes a combination of analysis axes related to the first question as a filtering condition; A data extraction step in which relevant patent data is extracted from the patent data using the filtering conditions included in the quantitative analysis results, The steps include sending a second prompt to the language model, which includes a natural language question received from the user and the extracted related patent data, and obtaining a qualitative analysis result from the language model by analyzing the content of the related patent data, An output step that outputs the quantitative analysis results and the qualitative analysis results, A patent data analysis method that performs this analysis.

Images