Idea generation support program and methods

Abstract

We provide methods to support idea generation. [Solution] The computer is instructed to perform the following processes: inputting a large-scale language model with multiple information strings relating to a predetermined subject and analysis instruction information including instructions to perform an analysis on a predetermined subject-specific product based on the multiple information strings, and obtaining an output of an analysis result string from the large-scale language model; and inputting a large-scale language model with multiple information strings and solution generation instruction information instructing the generation of a solution corresponding to the analysis result string, and obtaining an output of a solution string corresponding to the analysis result string from the large-scale language model.

Description

Technical Field

[0001] The present invention relates to an idea support program and method.

Background Art

[0002] Patent Document 1 discloses an idea support method.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] In Patent Document 1, morphological analysis of natural language sentences is performed for idea support. However, when morphological analysis is performed, the context is lost, so it is necessary for humans to reconstruct the subsequent relationships.

[0005] The present invention has been made to solve such conventional problems, and an object thereof is to provide idea support.

Means for Solving the Problems

[0006] The present invention is an idea support program that causes a computer to input a large language model with a plurality of information strings related to a predetermined theme and analysis instruction information including an instruction to analyze a predetermined theme-specific product based on the plurality of information strings, and obtain an output of an analysis result string from the large language model, and input the large language model with the plurality of information strings and solution generation instruction information for instructing generation of a solution corresponding to the analysis result string, and execute a process of obtaining an output of a solution string corresponding to the analysis result string from the large language model.

Effects of the Invention

[0007] According to the idea generation support method and program of the present invention, a large-scale language model is used to deeply analyze a specific problem from multiple information strings while preserving contextual information, and to generate concrete solution proposals based on the analysis results. This solves the problem of context loss that occurs in conventional methods using morphological analysis, and the difficulty of deep analysis and concrete solution generation that is difficult with simple use of LLM, thereby realizing more efficient and high-quality idea generation support. [Brief explanation of the drawing]

[0008] [Figure 1] Schematic diagram of a system for implementing idea generation support methods [Figure 2] Block diagram of the terminal [Figure 3] Flowchart for Idea Generation Support Program [Figure 4] Flowchart for Idea Generation Support Program [Modes for carrying out the invention]

[0009] The following describes in detail, with reference to the figures, an embodiment of the idea generation support program and method.

[0010] Figure 1 is a schematic diagram of the system that implements the idea generation support method. To implement the idea generation support, terminal 1 connects to natural language processing server 2 via a network.

[0011] Server 2 is a computer that processes input strings of natural language (in this embodiment, (problem, needs, marketing) analysis processing, solution generation processing, and evaluation processing). The natural language processing server in this embodiment is a server that provides a cloud-based service incorporating a large-scale language model such as OpenAI's GPT-4o, GPT-4o-mini, GPT-4 Turbo, and GPT-4 (all API services). However, Server 2 is not limited to these, and any server that performs natural language processing incorporating a large-scale language model that provides similar functionality (for example, Google's Gemini or Anthropic's Claude) would suffice.

[0012] The natural language processing server 2 of this embodiment includes a CPU, memory, input / output devices, and an external interface. It performs natural language processing incorporating a large-scale language model on input from an external device and outputs the result.

[0013] In this embodiment, natural language processing is performed on the server side, but it may also be performed on terminal 1. Various large-scale language models that can be executed on terminal 1 include Gemma (so-called local LLMs). In this case, server 2 is not required. Furthermore, not only large-scale language models but also small-scale language models may be used. Hereafter, large-scale and small-scale language models will be collectively referred to as language models.

[0014] Figure 2 is a block diagram of terminal 1 in the system for executing the idea generation support program / method of the embodiment. The terminal is, for example, a personal computer, tablet, or smartphone owned by the user.

[0015] Via the system bus 108, a CPU (Central Processing Unit) 101, a ROM (Read Only Memory) 102, a RAM (Random Access Memory) 103, a HDD (Hard Disk Drive) 105, an external I / F (Interface) 106, and an input unit 107 are connected. The control unit 104 is composed of the CPU 101, the ROM 102, and the RAM 103.

[0016] The ROM 102 stores in advance programs and threshold values to be executed by the CPU 101. The RAM 103 has various memory areas such as an area for expanding programs executed by the CPU 101 and a work area that serves as a work area for data processing by the programs.

[0017] The HDD 105 stores patent data (natural language text data) and the like input from the input unit 107. The external I / F 106 is an interface for communicating with external devices such as an external server (PC).

[0018] The external I / F 106 may be any interface for data communication with an external device. For example, it may be a device (such as a USB memory) that is locally connected to an external device, or it may be a network interface for communication via a wired or wireless network.

[0019] The control unit 104 exchanges data with an external device (server) via the external I / F 106 to transmit document data and instruction information and receive generation results such as solution information.

[0020] 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).

[0021] The processing procedure of the program for the idea support method of the embodiment will be described. In the embodiment, idea support for beer is performed, but the target products and services are not limited to this. Also, the target as a predetermined theme is not limited to products and services, and any target that can form a specific population (a set of multiple pieces of information) such as an applicant, a filing date, a patent classification, etc. is acceptable. A series of the following code blocks constitutes the program and method of the embodiment. However, for ease of explanation, it will be explained by dividing it into code blocks.

[0022] (First Embodiment) Figure 3 is a flowchart of the processing of the idea support processing program of the embodiment. Pretreatment is performed in STEP1, analysis processing is performed in STEP2, solution generation processing is performed in STEP3, evaluation processing is performed in STEP4, and specification creation processing is performed in STEP5. Note that STEP4 and 5 are additional steps and not essential steps.

[0023] In the embodiment, beer is taken as an example of a predetermined theme, and a summary of patent data related to beer is used as an information string related to the product consisting of natural language regarding a predetermined product. However, the target of the information string is not limited to the summary of patent data. For example, it can widely target various forms of natural language text data (including unstructured data) related to a specific product or service, such as the full text of the specification of a patent gazette, the text data of claims, academic papers related to the product, technical reports, market research reports, free-form answers to consumer questionnaires, online reviews, and posts on social media.

[0024] (STEP1: Pretreatment) The control unit 104 extracts text from the abstracts (multiple information strings related to a specific product) of multiple patent data relating to a specific product. The program is as follows. Note that the following program is a Python program stored in the control unit of terminal 1. However, it is not limited to this, and other programming tools and programming languages ​​(such as VBA or GAS) may be used. Also, the following program is merely an example, and the processing order, libraries, functions, and variable names used may be changed.

[0025] # ===== 1. Pre-treatment process ===== import pandas as pd import json import google.generativeai as genai from google.colab import drive # Mounting Google Drive drive.mount(' / content / drive') # Setting up the Gemini API key # (omission) # Gemini Model Selection model = genai.GenerativeModel('gemini-2.5-flash-preview-04-17') # Loading patent data df = pd.read_excel(' / content / drive / MyDrive / beer_patent_100.xlsx') # Data preprocessing: Extract only the summary and convert to JSON format. def create_patent_dict(row): return { f"Application {row.name}": { "Summary": row['Summary'] } } patent_list = df[['Abstract']].apply(create_patent_dict, axis=1).tolist() json_output = json.dumps(patent_list, ensure_ascii=False, indent=2)

[0026] The program can be described as follows:

[0027] • Cloud storage integration processing In this embodiment, Google Drive is used as cloud storage. The control unit 104 mounts Google Drive and enables access to the patent data. This process makes it possible to access files on Google Drive via the ' / content / drive' path.

[0028] • API key setup and AI model generation initialization process In this embodiment, the Google Gemini API is used to analyze patent data. The control unit 104 sets the API key and initializes the generated AI model. This process initializes the latest generated AI model "gemini-2.5-flash-preview-04-17" and makes it available for use in analyzing patent data.

[0029] • Patent data acquisition process In this embodiment, patent data is obtained from an Excel file. The control unit 104 reads the Excel file using the pandas library. This process reads the Excel file containing the patent information as a DataFrame. Specifically, it contains data on 100 beer-related patents downloaded from J-platpat.

[0030] • Data preprocessing In this embodiment, necessary information (abstract) is extracted from the acquired patent data and converted into a JSON format that is easy for the generating AI model to process. The control unit 104 performs data preprocessing. In this process, the create_patent_dict function is first applied to each patent data to generate a dictionary structure that includes the "application number" and "abstract". Next, the list of generated dictionaries is converted into JSON format, and the ensure_ascii=False parameter is set to correctly process Japanese characters. Furthermore, the indent=2 parameter is used to generate a highly readable JSON format. Note that the JSON format may include not only the abstract but also other information such as the application date, applicant, FI, etc.

[0031] (STEP 2: Problem Analysis) Next, the control unit 104 sends to the AI ​​server 2 a prompt consisting of multiple information strings relating to a predetermined subject, such as a specific product or service, and problem analysis instruction information (analysis instruction information) that includes an instruction to analyze problems relating to the specific product from the multiple information strings, and receives the output of a problem analysis result string from the AI ​​server 2. The program is as follows. Note that the analysis content is not limited to problems and may be changed to, for example, applications, according to the user's request.

[0032] # ===== 2. Analysis process ===== def generate_analysis_content(text): prompt = [ "The following is a compilation of multiple patent application information in JSON format." "Each patent listing includes an abstract." "Please conduct a thorough analysis of the 'Abstract' section of each patent included in this data." "Furthermore, please identify one technical challenge that you consider particularly important for advancing future research and development." Please describe the identified issues and the reasons for them in the following format: "", "Identified issues:", [Describe the identified issues here] "", "Reason for identification:", [Describe the reason for identifying the issue here] text ] response = model.generate_content( prompt, generation_config=genai.types.GenerationConfig( Temperature = 0, max_output_tokens=10000 ) ) Return response.text # Execute analysis analysis_content = generate_analysis_content(json_output) print(analysis_content)

[0033] The program for this part is explained as follows:

[0034] The control unit 104 receives multiple patent information (in JSON format) using this Python code (generate_analysis_content function), analyzes the "summary" portion, identifies one technical issue that is considered important for future research and development, and outputs it as text along with the reason. In this embodiment, an issue analysis is performed, but the analysis content is not limited to issues; it could also be a needs analysis or a marketing analysis. LLM can perform various analyses by changing the prompt. For example, the following analyses are also possible: Needs analysis: Identify unmet customer or market demands. Opportunity analysis: Discover new technological and market opportunities. Trend analysis: Understand technological and market trends and patterns. Competitive analysis: Analyze the trends, strengths, and weaknesses of competitors.

[0035] The prompt will include the following: Input: The input must be a summary of patent information. Task: In-depth analysis of the summary to identify the single most important technical challenge. Output: Describe the identified issues and reasons in the specified format ("Identified Issues:", "Reasons for Identification:").

[0036] The control unit 104 adds the actual patent information to be analyzed (the input JSON data) to this prompt and sends the created prompt to the server 2.

[0037] Server 2 follows the prompt's instructions, analyzes the patent abstract, and generates the issues and reasons in the specified format. Server 2 returns the generated text (identified issues and reasons) as the result of the function.

[0038] The last part of the code (generate_analysis_content(json_output) and print(...)) actually calls this function to display the obtained analysis results (issue analysis result string). An example of an issue analysis result string received from Server 2 is shown below. This string shows the important technical issues in the product field and their rationale, extracted and analyzed by LLM from multiple input information strings.

[0039] (Generated problem analysis result string) Identified challenge: Achieving both a beer-like body and flavor in low-alcohol or low-sugar beer-flavored beverages. • Reason for identification: Analysis of the provided patent abstracts revealed that many applications aim to impart functionality such as "low alcohol" or "low sugar (including zero sugar)" to beer-flavored beverages, while simultaneously maintaining and improving the positive characteristics inherent to beer, such as "satisfaction," "richness," "depth of flavor," "crispness," and "malty taste," or suppressing and reducing negative characteristics such as "wateriness," "off-flavors," "off-odors," and "sourness." This reflects a strong market need: modern consumers, increasingly health-conscious, are seeking low-alcohol and low-sugar beverages, while simultaneously expecting beer-flavored drinks to offer a satisfying taste and aroma comparable to traditional beer. However, since alcohol and sugars are components that greatly contribute to the body and complex flavor of beer-flavored beverages, reducing them generally tends to result in a loss of body, a watery taste, and a more noticeable off-flavor or unpleasant taste derived from the raw materials. Therefore, the technology to reproduce and improve the complex and satisfying taste and aroma characteristic of beer, while reducing alcohol and sugar content, through adjustments to other components (e.g., adjusting the content of specific peptides, amino acids, and aroma components) and improvements to the manufacturing process, is considered technically challenging and extremely important for differentiating oneself in future market competition. The fact that multiple patent applications address this challenge further supports its importance.

[0040] (STEP 3: Solution Generation) Next, the control unit 104 sends multiple information strings and solution generation instruction information that instructs the server 2 to generate solutions corresponding to the problem analysis result strings, and receives the output of solution strings corresponding to the problem analysis result strings from the server 2. The program is as follows.

[0041] # ===== 3. Idea Generation Process ===== def generate_solution_content(text): prompt = [ f"The following text is a summary of the following assignment:\n\nAssignment content:\n{analysis_content}", "Combine these summaries to come up with one detailed beer solution that addresses the problem described in the problem statement." "Please describe your proposed solution and its explanation in the following format." "", "Proposed solution:" [Describe the proposed solution here] "", "The explanation:", [Explanation goes here] text ] response = model.generate_content( prompt, generation_config=genai.types.GenerationConfig( Temperature = 0, max_output_tokens=10000 ) ) Return response.text # Solution generation solution_content = generate_solution_content(json_output) print(solution_content)

[0042] The program for this part is explained as follows:

[0043] The control unit 104 receives the "problem description" and "summary" (in JSON format) identified in the previous step using this Python code (generate_solution_content function), combines this information to devise a specific "beer solution proposal" to solve the problem, and outputs it along with an explanation.

[0044] The prompt will include the following: Input: Provide the "problem description" to be solved (results from the previous step, analysis_content) and the "summary" to be used as reference (input text). Task: Combine these summaries to devise one detailed beer solution that addresses the presented problem. Output: Describe your proposed solution and its explanation in the specified format ("Proposed Solution:", "Explanation:"). Add the actual technical summary to be analyzed (the entered JSON data, text) to this prompt.

[0045] The control unit 104 sends the generated prompt to the server 2 (LLM). The server 2, following the instructions in the prompt, understands and combines the presented problem and summary, and generates a proposed solution and its explanation in the specified format. The text generated by the server 2 (the proposed solution and its explanation) is sent to terminal 1 as the result of the function. The last part of the code (generate_solution_content(json_output) and print(...)) actually calls this function to display the obtained proposed solution. An example of a proposed solution is shown below.

[0046] (Generated solution proposals) • Proposed solution: A low-alcohol, low-sugar beer-flavored beverage combining "high-density flavor peptide fermentation" and "off-flavor / flavor balance control." • Explanation: This proposed solution aims to achieve a high level of balance between the "satisfaction" and "complex flavor" inherent in beer, while realizing the functionality of low alcohol (e.g., around 1.0-3.8 v / v%) and low carbohydrate content (e.g., zero to 2.0 g / 100mL or less). This overcomes challenges such as lack of body, wateriness, and the emergence of off-flavors and impurities derived from the raw materials that can result from low alcohol and carbohydrate content, by combining multiple technological elements. Specifically, the following technical elements will be applied in an integrated manner. • Improved body and richness of flavor through high-density flavor peptide fermentation: The malt ratio is 50% by mass or more, and the flavor is based on malt. We optimize raw material processing (such as saccharification conditions) and fermentation conditions to ensure a rich content of peptides within specific molecular weight ranges (e.g., 800-1500 kDa, 10-20 kDa). These peptides contribute to the beer's characteristic softness, smooth texture, flavor persistence, depth of flavor, and richness, even under low-carbohydrate conditions. If necessary, we also incorporate processes to blend specific peptides. By carefully managing the total nitrogen content and free amino nitrogen (FAN), we enhance the structure and depth of the flavor. In particular, by adjusting the content of bitter amino acids, we achieve a balance between a strong bitterness and a crisp finish. Increasing the pyroglutamic acid content provides a more satisfying drinking experience. By optimizing the content of sugars such as maltose and maltotriose within a low-sugar range, or by adjusting the ratio of medium-chain sugars such as maltotetraose to short-chain sugars, we achieve a balance between a refreshing taste and a satisfying drinking experience. • Off-flavor suppression and flavor balance control: We employ raw material selection and processing methods that reduce the proportion of amino acids (such as valine, leucine, and isoleucine) that contribute to off-flavors originating from the raw materials. Off-flavor components such as sotolon, dimethyl sulfone, and 2-methylbutyrate are either coexisted with or their generation controlled by masking agents (such as 3-mercaptohexanol, 3-(methylmercapto)propionic acid, and 2-acetylpyrazine) in specific ratios. It inhibits or eliminates the production of astringent or unpleasant-smelling compounds such as 2,6-nonadienal. By optimizing the concentration balance of acidic and ester components such as acetic acid, ethyl acetate, and isoamyl acetate, we suppress the overpowering acidity while imparting a beer-like fruitiness and maturity. We also adjust the phenethyl alcohol and 1-propanol / ethanol ratio to reduce the sharp acidity. By appropriately incorporating aromatic components such as linalool and cis-linalool oxide, we achieve a vibrant and complex fragrance even with low alcohol and sugar content. The concentrations of butyric acid and certain aldehydes (such as 1-phenyl-3-buten-1-one, trans-2-hexenal, nonanal, trans-2-nonenal, and hexanal) are adjusted to emphasize a refreshing crispness and smooth finish. By controlling the components responsible for aftertaste and lingering bitterness (such as the balance between 40kDa protein and ferulic acid, and tetracyclon-normalfumol), we achieve a smooth drinking experience. • Optimized manufacturing process: By employing specific yeasts (e.g., bottom-fermenting yeast) and fermentation temperatures and yeast concentrations that control the production of flavor components, negative flavors such as bitterness and sourness are reduced. We carefully control the degree of fermentation. For example, by adjusting the visible fermentation level to a specific range (e.g., 5-80%), we can suppress wateriness and maintain a satisfying mouthfeel. Alternatively, we can consider an approach that involves thoroughly consuming carbohydrates with a high degree of fermentation (e.g., 105% or more) while reinforcing the mouthfeel and flavor with other components. Low-temperature mixing after fermentation maintains and enhances the fresh aroma and flavor. If necessary, activated carbon treatment efficiently reduces unwanted off-flavor components, purines, and carbohydrates. By optimizing the hop addition method and utilizing silicone-based defoaming agents, we optimize the quality and transfer rate of bitterness. By combining these technological elements, we aim to achieve a "beer-like drinking experience and flavor" through a new approach that does not rely on alcohol or sugar. In particular, the core of this solution lies in building body through the control of peptide composition and suppressing off-flavors and imparting positive flavors by adjusting the balance of various aroma and taste components.

[0047] (STEP 4: Evaluation) Next, the control unit 104 sends the solution string and evaluation instruction information instructing the server 2 to evaluate the solution string against the problem analysis result string, and receives the evaluation string output of the solution string against the problem analysis result string from the server 2. The program is as follows.

[0048] # ===== 4. Evaluation Process ===== def generate_solution_evaluation(): prompt = f""" The following text presents a proposed solution to the following problem: Assignment details: {analysis_content} Evaluate the effectiveness of the proposed solutions to the given problem and rate them out of 100 points. {solution_display} """ response = model.generate_content( prompt, generation_config=genai.types.GenerationConfig( Temperature = 0, max_output_tokens=10000 ) ) Return response.text # Run the evaluation solution_evaluation = generate_solution_evaluation() print(solution_evaluation)

[0049] The program for this part is explained as follows:

[0050] The control unit 104 receives the "problem description" identified in the previous step and the "solution proposal" devised for it using this Python code (generate_solution_evaluation function), evaluates how effective the solution proposal is in solving the problem, and assigns a score out of 100 points. Note that the evaluation is not limited to a score; it can also be good or bad, or the user can be asked to explain it in writing. By changing the prompt, LLM can perform various evaluations. For example, it is possible to perform evaluations from a variety of perspectives, such as the following: Novelty and inventiveness evaluation: How new and advanced is the generated solution compared to existing technologies and ideas? Feasibility evaluation: How feasible is the solution from a technical, cost, and time perspective? Marketability evaluation: The likelihood of the solution being accepted in the market, differentiation from competitors, potential market size, etc. Risk evaluation: Potential technical risks, business risks, side effects, etc. associated with the introduction of the solution. Multifaceted comparative evaluation: Generate multiple solution proposals and compare and evaluate them using various criteria (cost, effectiveness, feasibility, etc.). Suggestions for improvement: Point out the weaknesses in the generated solution proposals and ask for specific improvement measures.

[0051] The prompt will include the following: Input: Provide the "problem description" (analysis_content) to be solved and the "proposed solution" (solution_content) to be evaluated. Task: Evaluate how effective the proposed solutions are in addressing the problem, and assign a score out of 100 points. Output: Outputs text containing evaluation scores and their rationale.

[0052] The control unit 104 sends the generated prompt to the server 2 (LLM). The server 2 follows the instructions in the prompt, compares and examines the problem and proposed solutions, evaluates their effectiveness, and generates a score. The server 2 returns the generated text (evaluation score, evaluation reason, etc.) as the result of the function. The last part of the code (generate_solution_evaluation() and print(...)) actually calls this function and displays the obtained evaluation result. An example of the evaluation result is shown below.

[0053] (Generated evaluation string) • Evaluation of the effectiveness of proposed solutions The proposed solutions address the challenge of "achieving both a beer-like drinking experience and flavor in low-alcohol or low-sugar beer-flavored beverages" with a very specific and multifaceted approach, and their effectiveness can be highly evaluated. • Rating: 95 points • Reason for evaluation: Effective responses to challenges and a deep understanding of the root causes of those challenges: The proposed solution clearly sets the goal of achieving both "satisfaction" and "flavor," which are the challenges. The company accurately identifies the root causes of issues such as a lack of body, wateriness, and the emergence of off-flavors due to low alcohol and sugar content, and proposes multiple specific countermeasures. This demonstrates a deep understanding of the challenges. • Technical specificity and comprehensiveness: Rather than merely providing abstract guidelines, the manual specifically lists ingredients related to "drinkability and depth of flavor," such as peptides within a specific molecular weight range, total nitrogen content, FAN, pyroglutamic acid, and specific sugar ratios, as well as ingredients related to "flavor and off-flavors," such as sotolon, dimethyl sulfone, 2,6-nonadienal, various acids and esters, linalool, butyric acid, and certain aldehydes, and explains in detail how to adjust each and the expected effects. The proposals cover the entire manufacturing process, including raw material selection, saccharification and fermentation conditions, yeast selection, fermentation degree control, and post-processing (low-temperature mixing, activated carbon treatment), demonstrating a very comprehensive approach to solving the challenges. • Presentation of evidence based on patent information: In the description of each technical element, numerous patent abstract application numbers are cited. This indicates that the proposed technology is not merely theoretical but is based on technology that companies are actually researching and developing and considering at the patent application level, thereby increasing the feasibility and reliability of the proposed solution. • An integrated and logical approach: We have established two clear pillars: building body and depth of flavor through "high-density flavor peptide fermentation," and suppressing negative elements and imparting positive flavors through "off-flavor and flavor balance control." Under these pillars, a diverse range of technological elements are logically arranged, and how each contributes to solving the problem is clearly explained. It is an ambitious structure that attempts to recreate the characteristics of beer with a new approach that does not rely on alcohol or sugar. • High potential for problem-solving: The approach of replacing or enhancing the body and complex flavors previously provided by alcohol and sugars through optimizing peptide composition and balancing diverse aroma and taste components is technically challenging, but if successful, it has the potential to effectively solve problems and achieve market differentiation. The 5 points deducted are for the following reasons: The proposed technological elements are diverse and intricately interconnected. When these technologies are actually combined, it is possible that unexpected interactions or new challenges may arise (e.g., the creation of other off-flavors due to increasing certain components, increased costs, etc.). While the proposed solution is excellent, further detailed technical verification and optimization are necessary for actual product development, so it did not receive a perfect score. However, the proposed solutions capture the core of the problem, present concrete and comprehensive solutions based on existing technological knowledge (patent information), and serve as a very strong starting point for solving the problem.

[0054] (STEP 5: Prepare the statement) Next, the control unit 104 sends solution information and claim generation instruction information to the natural language processing server 2 and receives the claim string from the natural language processing server 2. The program is as follows. Note that STEP 5 onwards shows an example using OpenAI's API.

[0055] # ===== 5. Claim generation process ===== def generate_patent_claims(solution_text): response = client.chat.completions.create( model="gpt-4o-mini" Messages=[ { "role": "system", "content": ( "Based on the following proposed beer solution, please generate one main claim and four dependent claims." ) }, {"role": "user", "content": solution_text} ], Temperature = 0, max_tokens=5000, frequency_penalty=0, presence_penalty=0, ) patent_claims = response.choices[0].message.content return_claims # Generate patent claims based on the recommended solution patent_claims = generate_patent_claims(solution_content) print("===== Generated patent claims (5) =====") print(patent_claims)

[0056] This code is designed to implement a process for automatically generating patent claims. First, a function called `generate_patent_claims` is defined. This function takes the text of a proposed solution (solution information) as input and generates patent claims based on it.

[0057] Within the function, the `client.chat.completions.create` method is used. This is the part that calls the GPT-4o-mini model. This model receives instructions for generating patent claims (claim generation instructions) and a proposed solution (solution information). The instructions (claim generation instructions) state, "Generate one main claim and four dependent claims based on the following proposed solution." These instructions serve to clearly communicate the specific structure and quantity of the patent claims to be generated.

[0058] The response returned from the model as a result of the function execution is obtained from response.choices[0].message.content. This content becomes the value returned by the function as the patent claim. After the function is defined, this code calls the generate_patent_claims function with the solution information stored in the variable solution_content as input. As a result, the generated patent claims are stored in patent_claims. Finally, these generated patent claims are output to the console and displayed. The claim string generated by natural language processing server 2 is shown below.

[0059] (Generated claim string) ===== Generated Patent Claims (5 claims) ===== ### Main claim Claim 1: (Main Claim) A beer-flavored beverage having a malt ratio of 50% by mass or more, an alcohol content of 1.0 to 3.8 v / v%, and a carbohydrate content of 2.0 g / 100 mL or less, characterized in that it contains a peptide having a molecular weight in the range of 800 to 1500 Da or 10 to 20 kDa, and also contains pyroglutamic acid. Claim 2: (Dependent claim relating to off-flavor suppression) The beer-flavored beverage according to claim 1, further comprising at least one masking component selected from 3-mercaptohexanol, 3-(methylmercapto)propionic acid, and 2-acetylpyrazine, wherein the masking component suppresses off-flavors derived from sotolon, dimethyl sulfone, or 2-methylbutyric acid. Claim 3: (Dependent claim relating to reduction of off-flavors) The beer-flavored beverage according to claim 1 or 2, characterized in that the content of an amino acid selected from valine, leucine, and isoleucine is reduced in order to reduce off-flavors derived from the raw materials. Claim 4: (Dependent claim relating to aroma components) A beer-flavored beverage according to any one of claims 1 to 3, characterized in that it contains linalool or cis-linalool oxide and the concentration balance of acetic acid, ethyl acetate, and isoamyl acetate is adjusted. Claim 5: (Dependent claim regarding manufacturing process and degree of fermentation) A beer-flavored beverage according to any one of claims 1 to 4, characterized in that the apparent degree of fermentation is adjusted to be in the range of 5 to less than 80%, or the apparent degree of fermentation is 105% or more and is treated with activated carbon.

[0060] Next, the control unit 104 sends the claim string and patent specification generation instruction information to the natural language processing server 2 and receives the patent specification string from the natural language processing server 2. The program is as follows.

[0061] # ===== 6. Statement generation process ===== def generate_patent_specification(patent_claims): response = client.chat.completions.create( model="gpt-4o-mini" Messages=[ { "role": "system", "content": ( "Please generate a patent specification based on the following claims." ) }, {"role": "user", "content": patent_claims} ], Temperature = 0, max_tokens=5000, frequency_penalty=0, presence_penalty=0, ) patent_specification = response.choices[0].message.content return pet_specification # Generate a patent specification based on the generated patent claims (patent_claims). patent_specification = generate_patent_specification(patent_claims) print("===== Generated Patent Specification =====") print(patent_referenceation)

[0062] This code implements a mechanism for generating a patent specification based on patent claims. First, a function called `generate_patent_specification` is defined. This function takes claim information as input and generates a patent specification based on its contents. Inside the function, the `client.chat.completions.create` method is used to call the GPT-4o-mini model. This method instructs the model to generate a patent specification.

[0063] The input message to the model consists of two parts. The first part is an instruction statement as the system role (specification generation instruction information), which includes the content, "Generate a patent specification based on the following claims." This allows the model to understand the specific tasks required to generate the specification. Next, the user provides the text of the generated patent claims (claim string). This claim information forms the basis for specification generation.

[0064] The response returned by the model is obtained from response.choices[0].message.content. This response becomes the return value of the function as the text of the patent specification (patent specification string). This function is used to generate a patent specification based on the patent claims stored in the variable patent_claims. The result is stored in the variable patent_specification. Finally, the content of the generated patent specification is output. The specification string generated by natural language processing server 2 is shown below.

[0065] (Generated statement string) ===== Generated Patent Specification ===== Patent specification (draft) [Title of the invention] Beer-flavored beverage [Technical field] This invention relates to a beer-flavored beverage that is low in alcohol and sugar, yet possesses the characteristic taste and flavor of beer. [Background technology] In recent years, with consumers' increasing health consciousness, there has been a growing demand for beverages with reduced alcohol content and functional beer-flavored beverages with reduced sugar content. However, in typical beer-flavored beverages, reducing alcohol and sugar content often results in a loss of the "body" (richness of flavor) and "satisfaction" that these elements originally provided, leading to a watery taste. Furthermore, the weakening of the masking effect of alcohol and sugar can lead to a problem where grain odors (wort odor) derived from the wort, unpleasant off-flavors from fermentation, or off-flavors derived from the raw materials become more prominent. Traditionally, this has been compensated for by adding flavorings, acidulants, and sweeteners, but this sometimes deviated from the natural flavor balance inherent in beer. [Problems the invention aims to solve] This invention has been made in view of the above circumstances, and aims to provide a beer-flavored beverage that satisfies the functional requirements of being low in alcohol (approximately 1.0-3.8 v / v%) and low in carbohydrates (2.0 g / 100 mL or less), while highly achieving both the "authenticity and richness of real beer" and "good aroma and flavor without off-flavors," which were difficult to achieve with conventional technology. [Means for solving the problem] As a result of diligent research to solve the above problems, the inventors of this invention have discovered that the body can be enhanced by controlling the content of peptides having a specific molecular weight range, and that off-flavors can be effectively suppressed under low-alcohol and low-sugar conditions by coexisting with specific masking components, thus completing the present invention. In other words, the gist of this invention is as follows: (1) A beer-flavored beverage having an alcohol content of 1.0 to 3.8 v / v% and a carbohydrate concentration of 2.0 g / 100 mL or less, characterized in that it contains a peptide having a molecular weight in the range of 800 to 1500 Da or 10 to 20 kDa, and contains at least one component selected from the group consisting of 3-mercaptohexanol, 3-(methylmercapto)propionic acid, and 2-acetylpyrazine. (2) The beer-flavored beverage according to (1) above, characterized in that the malt usage ratio is 50% by mass or more and contains pyroglutamic acid. (3) The beer-flavored beverage according to (1) or (2), comprising at least one off-flavor component selected from the group consisting of sotolon, dimethyl sulfone, and 2-methylbutyric acid, wherein the content of 3-mercaptohexanol, 3-(methylmercapto)propionic acid, or 2-acetylpyrazine is such that it masks the off-flavor component. (4) A beer-flavored beverage according to any one of (1) to (3) above, characterized in that it contains medium-chain sugars including maltotetraose and short-chain sugars including maltose and maltotriose, and the ratio of the medium-chain sugars to the short-chain sugars is adjusted. (5) A beer-flavored beverage according to any one of the above items (1) to (4), characterized in that it contains a protein with a molecular weight of 40 kDa and ferulic acid, and the balance of these contents is adjusted, or the degree of fermentation is in the range of 5 to less than 80%, or 105% or more. [Effects of the invention] According to the present invention, it is possible to provide a beer-flavored beverage that, despite having low alcohol and sugar content, possesses both the richness of flavor derived from specific peptides and a clean aroma free from off-flavors due to a masking effect. This makes it possible to provide a beverage that offers high satisfaction as a luxury item, even to consumers who prioritize health benefits. [Modes for carrying out the invention] Embodiments of the present invention will be described in detail below. The beer-flavored beverage of the present invention has an alcohol content of 1.0 to 3.8 v / v% and a carbohydrate concentration of 2.0 g / 100 mL or less. Within this range, the desired flavor is achieved by combining the following technical elements. <Adding body through high-density flavor peptides> In this invention, peptides are utilized as a basis for body, replacing carbohydrates and alcohol. In particular, peptides with molecular weights in the range of 800-1500 kDa or 10-20 kDa are important components that contribute to flavor persistence, richness, and depth. These peptides can be incorporated into beverages at high density by optimizing the protease action conditions (temperature, pH, time) during the mashing process (saccharification process) using malt-derived proteins, by fermentation using yeast with specific peptide-producing capabilities, or by adding peptides from external sources. Furthermore, it is preferable to increase the pyroglutamic acid content to enhance the flavor profile. Pyroglutamic acid imparts a sense of maturity and a well-rounded flavor, compensating for the lack of satisfaction often associated with low-alcohol beverages. <Controlling off-flavors and flavor balance> In low-alcohol, low-sugar beverages, off-flavors such as sotolon (burnt smell, sweet, stale rice smell), dimethyl sulfone, and 2-methylbutyric acid (sweaty smell, cheesy smell) are more easily detected above the threshold. In this invention, in addition to physically removing these off-flavors, components with masking effects are actively utilized. Specifically, components such as 3-mercaptohexanol (fruity, citrus-like), 3-(methylmercapto)propionic acid, and 2-acetylpyrazine (savory) are coexisted in a specific ratio that prevents the detection of the aforementioned off-flavors. These components can be generated by selecting hops (variety, timing of addition) and controlling the metabolism of yeast. <Optimization of sugar composition> Although this invention is low in carbohydrates (2.0g / 100mL or less), the composition (quality) of the remaining trace amounts of carbohydrates is also important. Short-chain sugars such as maltose and maltotriose contribute to sweetness and fermentability, while medium-chain sugars such as maltotetraose provide body without giving a sweet taste. By adjusting the ratio of these, it is possible to achieve both a non-sticky "refreshing feel" and a "satisfying drinkability" that is not watery. <Other ingredients and manufacturing process> To control the bitterness and astringency of the aftertaste, it is preferable to adjust the balance between a protein with a molecular weight of 40 kDa and ferulic acid. In the manufacturing process, either a method that limits the degree of fermentation to less than 5-80% to retain the extract derived from the malt, or conversely, a method that reduces the sugar content to the absolute minimum with a high degree of fermentation of 105% or more, while reconstructing the flavor with the aforementioned peptides, can be employed. It is desirable to base the beer on the original malt flavor by using a malt usage ratio of 50% by mass or more. [Examples] The present invention will be described in more detail below with reference to examples, but the present invention is not limited to these examples. (Manufacturing example) The malt ratio was 60%, and barley and other ingredients were used as adjuncts. Peptide production was controlled by adjusting the protein resting time during the brewing process. Bottom-fermenting yeast was used for fermentation, and fermentation was stopped or adjusted by dilution when the alcohol content reached approximately 3.0%. Analysis revealed that the resulting beverage contained 1.2 times the amount of peptides with molecular weights of 800-1500 Da compared to regular beer, and an appropriate amount of 3-mercaptohexanol was detected. In sensory evaluation, compared to the control group (regular low-carbohydrate beer-flavored beverage), it received evaluations such as "richer," "not watery," and "no noticeable off-flavors." [Industrial applicability] According to the present invention, it is possible to provide a beer-flavored beverage that satisfies health-conscious needs while offering high flavor satisfaction, making it extremely useful in the food and beverage industry. [Explanation of symbols] none

[0066] In this embodiment, a draft claim is generated from a proposed solution, and a draft patent specification is generated from this draft claim. However, it is also possible to create a draft patent specification from a proposed solution.

[0067] As described above, according to the first embodiment, by utilizing a large-scale language model, it becomes possible to comprehensively and objectively extract technical challenges from a large amount of information, efficiently generate and evaluate novel technical solutions to those challenges, and create draft specifications, compared to manual analysis. This significantly reduces the time and effort in the ideation process and facilitates the discovery of solutions that tend to be overlooked with conventional methods.

[0068] (Second Embodiment) The processing procedure of the program for the idea generation support method of the second embodiment will be described. Note that in this embodiment, idea generation support is provided for beer, but the target product (predetermined subject) is not limited to this. The following code blocks 1 to 6 constitute the program and method of the embodiment. However, for ease of explanation, the code blocks 1 to 6 will be explained separately. Furthermore, the system configuration is the same as in the first embodiment, so its explanation will be omitted.

[0069] In the program for the idea generation support method of the second embodiment, in response to a user's request regarding a product (user request input string: "I want to drink a refreshing beer!"), the program extracts solutions with related problems from patent data and generates a solution from these solutions that satisfies the user's request input string regarding the product. Note that the user request input string is not limited to this and can be anything as long as it is a request for beer (a predetermined subject).

[0070] Figure 4 is a flowchart of the processing of the idea generation support program of the embodiment. In STEP 1, multiple problem strings (first strings) and multiple solution strings (second strings) that are paired with each other are extracted from multiple summaries (multiple strings related to a specific product) of patent data relating to a predetermined product. In STEP 2, the degree of relevance between each of the multiple problem strings (first strings) and the user request input string entered by the user is evaluated. In STEP 3, one or more solution strings (second strings) that correspond to (pair with) the problem strings (first strings) with a high degree of relevance are extracted. In STEP 4, a solution corresponding to the user request input string entered by the user is generated based on the extracted solution strings (second strings) (the evaluation step and specification creation step are the same as in the first embodiment and are therefore omitted).

[0071] In this embodiment, a summary of patent data related to beer is used as the string of natural language relating to a predetermined product. However, the target string is not limited to this; it may also be a string from the main text of the specification or from the claims. Furthermore, strings of natural language other than patent data, such as questionnaires, user reviews, or academic papers, may also be used as the target of processing.

[0072] (STEP 1: Step to identify problems and solutions) First, the control unit 104 extracts the string of the problem (first string) and the corresponding string of the solution (second string) from the abstracts of multiple patent data (multiple strings relating to a specific product). The program is as follows. Note that the following program is a Python (registered trademark, hereinafter the same) program stored in the control unit of terminal 1. However, it is not limited to this, and other programming tools or programming languages ​​(such as VBA or GAS) may be used. Also, the following program is merely an example, and the processing order, libraries, functions, and variable names used may be changed.

[0073] (Code block 1) import pandas as pd # Data loading # Using Google Drive from google.colab import drive drive.mount(' / content / drive') # Loading data (from Google Drive) df = pd.read_excel(' / content / drive / MyDrive / beer_patent.xlsx') # Separation of problems and solutions # Extract the strings between [Problem] and [Solution], and between [Solution] and [Selected Diagram], and add them as a new column (problem,solution). df['problem'] = df['summary'].str.extract('[problem](.+?)[solution]', expand=False) # Generate the 'solution' column df['solution'] = df['summary'].str.extract('[solution method](.+?)(?:[selected diagram]|$)', expand=False)

[0074] The program can be explained as follows: First, the control unit 104 imports the pandas module. pandas is a tool for performing data analysis in Python. Next, it imports the drive function from the google.colab module. drive is a function for accessing Google Drive. Note that Google is a registered trademark.

[0075] The control unit 104 executes the `drive` function to mount Google Drive to the path ' / content / drive'. Mounting means making Google Drive files and folders accessible on Google Colab.

[0076] The control unit 104 uses the pd.read_excel function to read the Excel file named beer_patent.xlsx located at the path ' / content / drive / MyDrive / beer_patent.xlsx' (note that the file format is not limited to Excel; CSV format is also possible using other functions). This Excel file contains patent data with multiple abstract data (natural language string data). This patent data is related to beer. When generating new beer solutions, this beer-related patent data is used. A portion of the abstract column of the patent data converted into a data frame is shown below.

[0077] (Summary column data) 0 [Summary] [Challenge] To achieve a beer-like taste and rich flavor while reducing purine concentration... 1. [Summary] [Challenge] To achieve a beer-like taste and rich flavor while reducing purine concentration... 2 [Summary] [Problem] To provide a beer-flavored beverage with reduced residual off-flavors. ... 3 [Summary] [Problem] Despite the malt content in the raw materials being 50% by mass or more, off-flavors derived from malt are present... 4 [Summary] [Problem] The malt usage ratio is 50% or more, and the carbohydrate content is 0.5g / 100... ... ... ... 95 [Summary] [Problem] To provide a beer-flavored beverage with an excellent balance of richness and crispness. ... 96 [Summary] [Problem] A method for producing a non-fermented beer-flavored beverage, wherein the concentration of DMTS can be determined... 97 [Abstract] [Problem] The present invention provides a means for reducing the astringency of beer-flavored beverages, ... 98 [Summary] [Problem] To provide a non-alcoholic beer-flavored beverage with a more defined taste. 99 [Summary] [Problem] To provide a beer-like sparkling beverage with suppressed carbon dioxide leakage. ...

[0078] The abstract column of the data frame stores the content of the patent abstract. Note that, due to space limitations, only the first 5 and a portion of the last 5 are shown as examples above, but in this embodiment, a data frame of 100 entries (100 rows) is used. Of course, more or fewer entries are possible. Also, due to space limitations, the full text of the abstract is not displayed in the abstract column above, but in reality, the full text of the abstract is stored in a single cell in Excel. Note that Excel is a registered trademark. Furthermore, other columns besides the abstract column will be added to the data frame through the following steps.

[0079] The control unit 104 assigns the read file to a variable called df. df is a tabular data structure called a data frame. By using df['Summary'], only the column named "Summary" is extracted from df. The summary column stores the content of the patent abstract, which is written in natural language.

[0080] The control unit 104 uses the str.extract function to extract the string portion from the summary column, specifically the part from "Problem" to "Solution." This part of the string represents the problem of the patent (referred to as problem string information). The extracted substring is added to a new column called "problem." By setting df['problem'] = ..., a new column named "problem" is created in df.

[0081] Similarly, the control unit 104 uses the str.extract function to extract the string portion from the summary column, from "Solution" to "Selected Figure". This string portion represents the patent's solution (referred to as solution string information). The extracted string portion is added to a new column called "solution". By setting df['solution'] = ..., a new column "solution" is created in df. A portion of the problem and solution columns converted into a data frame is shown below. Note that, due to space limitations, only the first 5 and a portion of the last 5 are shown as examples below, but in this embodiment, a data frame of 96 items (96 rows) is used. Also, due to space limitations, the full text of the problem and solution columns is not displayed above, but in reality, the full text of the problem and solution are each stored in a single cell in Excel.

[0082] (Data in the "problem" column) 0 A beer-flavored fermented alcohol that achieves a beer-like character and rich flavor while reducing purine concentration... 1. A beer-flavored fermented alcohol that achieves a beer-like character and rich flavor while reducing purine concentration... 2. To provide beer-flavored beverages with reduced lingering off-flavors. 3. A low-carb beer with a malt content of 50% or more by mass, yet with improved clarity and less off-flavor from malt... 4. The malt content is 50% or more, and the sugar content is 0.5g / 100ml or less, yet it has a sweet taste... ... 95. To provide a beer-flavored beverage with an excellent balance of richness and crispness. 96 A method for producing a non-fermented beer-flavored beverage, the method for which the concentration of DMTS can be reliably reduced, and the... 97 The present invention provides a means for reducing the astringency of beer-flavored beverages and for improving their mildness... 98. Offering a non-alcoholic beer-flavored beverage with a more defined taste. 99. To provide a beer-like sparkling beverage in which carbon dioxide leakage is suppressed.

[0083] (Data in the 'cutoff' column) 0 A beer-flavored fermented alcoholic beverage with reduced purine concentration, containing an original extract concentration... 1. A beer-flavored fermented alcoholic beverage with reduced purine concentration, wherein the molecular weight of the beverage is 20-100... 2. The proportion of malt in the raw materials is 45% by mass or more, and the isoamyl acetate concentration of the beer-flavored beverage is 2 mg / l... 3. The proportion of malt in the raw materials is 50% by mass or more, and the raw materials include sugars, and the sugar content of the beer-flavored beverage... 4. The proportion of malt in the raw materials is 50% by mass or more, and the alcohol content of the beer-flavored beverage is 3.7v / v%... ... 95. Beer-flavored beverages contain grain-derived ingredients, have a final fermentation level of 89% or higher, and have an amino acid concentration of... 96 A method for producing a non-fermented beer-flavored beverage, comprising heating a container containing copper in the heating section, and heating a sugar solution with a pH of 4.0 or higher... 97 The present invention relates to a bitterness-improving agent for beer-flavored beverages, comprising lipoxygenase-1-deficient barley as an active ingredient... 98. Weight ratio of polyphenols to total extract content (weight % of polyphenols / weight % of total extract content)... 99 A beer-like sparkling beverage characterized by containing polyglycerin fatty acid esters and linalool, poly...

[0084] In this embodiment, the strings "problem" and "solution" were extracted from the summary using regular expressions, but this is not the only method. For example, the entire summary (or a specific part or all of the specification) can be sent directly to the natural language processing server as string information, and the large-scale language model of the natural language processing server can be used to extract the problem and solution (in this case, the natural language processing server will generate a pair of problem (first string) and solution (second string)). However, it is preferable to include a step for extracting the strings "problem" and "solution" individually from the summary, as this can reduce the usage fee and processing time of the generating AI and improve the processing accuracy of subsequent processes by the natural language processing server 2.

[0085] (STEP 2: Assessment of relevance to the issue) Next, the control unit 104 sends task relevance evaluation instruction information (relevance evaluation instruction information), which includes instructions for evaluating the degree of relevance between each of the multiple task strings (first strings) and the request input string indicating the user's request for a specific target, to the natural language processing server 2 which has a large-scale language model. The control unit 104 then receives task relevance evaluation result information (first string relevance evaluation result information), which includes the output of the degree of relevance between each of the multiple task strings and the request input string, from the natural language processing server 2. The program is as follows.

[0086] (Code block 2) # Installing packages ! pip install openai import openai

[0087] This command is used to install the OpenAI Python library. The exclamation mark (!) indicates that the command should be interpreted as a shell command. `pip` is the Python package manager, and `install` is the command used to install the library.

[0088] The control unit 104 imports the Python library called openai. The openai library is used to perform various natural language processing tasks using the OpenAI API. Although using the openai library actually requires entering an API key, this is omitted from the program description to avoid problems with public release.

[0089] Next, the control unit 104 sends task relevance evaluation instruction information, which includes an instruction to evaluate the degree of relevance between the task string and the user request input string, to the natural language processing server 2, and receives task relevance evaluation result information from the natural language processing server 2. The program is as follows.

[0090] (Code block 3) # Determining the degree of relevance between the task and the question. def generate_similarity_gpt(text): response = client.chat.completions.create( model="gpt-4o-mini" Messages=[ {"role": "system", "content": "Judge the similarity between the following sentence and the sentence "I want to drink a refreshing beer!" using human perception, and indicate the result as a percentage. Please provide only the percentage value as output. "}, {"role": "user", "content": text}], Temperature = 0, max_tokens=100, frequency_penalty=0, presence_penalty=0, ) problem_similarity = response.choices[0].message.content return problem_similarity

[0091] This program uses OpenAI's language model "GPT-4o-mini" to provide a function for summarizing a given text. However, the language model is not limited to "GPT-4o-mini"; "GPT-4 Turbo" or other large-scale language models from other companies, or even the next version of the GPT series, may be used. These are known to exhibit high accuracy in natural language processing tasks.

[0092] The `generate_similarity_gpt(text)` function takes a single text (text) as an argument, and the control unit 104 calls OpenAI's Chat Completion API to evaluate the relevance of that text. The API sends a message consisting of two roles: system and user. The system sends a prompt that says, "Judge the similarity between the following sentence and the sentence 'I want to drink a refreshing beer!' using human judgment, and indicate it as a percentage. Please provide only the percentage value as output." This prompt is used as the task relevance evaluation prompt.

[0093] Furthermore, the issue relevance evaluation instruction information includes a user request input string, such as "I want to drink a refreshing beer!" While the user request input string can be any natural language request from the user, it goes without saying that using a question closely related to the beer issue will improve the accuracy of the response. The output is not limited to percentages; other numerical expressions, or natural language expressions such as large, medium, small, high, and low are also acceptable. The point is that it should be possible to compare and express the degree of relevance.

[0094] The natural language processing server 2 evaluates the given text (problem string) based on the problem relevance evaluation instruction information and returns problem relevance evaluation result information that includes the degree of relevance between the problem string and the user request string. The response from the natural language processing server 2 includes the evaluated percentage (problem relevance evaluation result information). The problem relevance evaluation result information is stored in the problem_similarity variable and returned as the output of the function.

[0095] (Code block 4) # Add the results of the problem relevance assessment to a new column (problem_similarity). df['problem_similarity'] = df['problem'].apply(lambda x: generate_similarity_gpt(x))

[0096] This part of the program is designed to evaluate the text in each row stored in the 'problem' column of the Pandas dataframe df using the generate_similarity_gpt function, and then add the results (problem relevance evaluation results) to a new column 'problem_similarity' in df.

[0097] The `generate_similarity_gpt` function receives formatted text and evaluates it using the GPT-4o-mini model. The evaluation result (percentage of relevance) is stored in a new column 'problem_similarity' in the dataframe `df`. A portion of the `problem_similarity` column, when converted to a dataframe, is shown below. In this embodiment, relevances of 10-80% were obtained. Note that, due to space limitations, only the first 5 and a portion of the last 5 are shown as examples below, but the embodiment uses a dataframe of 100 entries (100 rows). Of course, more or fewer entries are also possible.

[0098] (Data in the problem_similarity column) 0 70 1 70 2 10 3 70 4:30 ... 95 20 96 20 97 30 98 70 99 30

[0099] (STEP3: Extraction of solution) Next, the control unit 104 extracts problem strings with a relevance of a predetermined level or higher, extracts the solution string (second string) of the patent application that corresponds to this problem, and generates solution string information. The program is as follows.

[0100] (Code block 5) # Remove '%' from the problem_similarity column and convert to a numeric type. df['problem_similarity'] = df['problem_similarity'].str.rstrip('%').astype('float') # Extract the top 10 results from the problem_similarity column. top_10_similarity = df.nlargest(10, 'problem_similarity') # Extract the top 10 solutions from the solution column. top_10_solutions = top_10_similarity['solution'] # Convert a string from a Series object to a list solutions_list = top_10_solutions.tolist() # Combine the strings in the list into a single string all_solutions_combined = ' '.join(solutions_list)

[0101] This part of the program first removes the percent sign (%) from the problem_similarity column of the dataframe df and converts it to a numeric type (floating-point number). Specifically, it removes the percent sign from each entry in the problem_similarity column using the str.rstrip('%') method, and then converts it to a floating-point number using the astype('float') method.

[0102] Next, we extract the top 10 entries with the largest values ​​in the `problem_similarity` column. This is done using the `nlargest` method, and the extracted top 10 rows are stored in a new dataframe called `top_10_similarity`.

[0103] Next, select only the `solution` column from the `top_10_similarity` dataframe extracted above, and store the selected `solution` column in a new series called `top_10_solutions`. Then, use the `tolist` method to convert the `top_10_solutions` series into a Python list.

[0104] The converted list is stored in a new variable, `solutions_list`. Furthermore, the `join` method is used to combine each string in `solutions_list`, separated by spaces, into a single long string. This combined string is then stored in a new variable, `all_solutions_combined`.

[0105] The data for the top_10_solutions series is shown below (note that only a portion of the beginning of the solutions are displayed). As shown, solutions from patent applications for highly similar problems are extracted. In this embodiment, 10 patent applications for highly relevant problems were extracted, but depending on the evaluation policy, the number may be 10 or more, or 10 or less. Alternatively, patent applications with a predetermined degree of relevance (for example, 70% relevance) or higher may be extracted.

[0106] (Data from top_10_solutions) 44. Original extract concentration of 20.0% by mass or higher, and apparent fermentation level of 70.0% or higher, alcohol content... 46. ​​Contains hydrolyzed soy protein and alanine as fermentation ingredients, with a carbohydrate concentration of 2g / 100ml or less, 2mg... 0. Alcohol content is between 1.0(v / v)% and 3.8(v / v)%, and pyroglutamic acid content... 1. The malt ratio is 50% by mass or more and less than 100% by mass, and the alcohol content is 1.0(v / v)% or more and 4.5%... 3. The alcohol content is 10 v / v% or higher, and the ethyl caproate content is 0.7 mg / L or higher, and... 5. The alcohol content is 10 v / v% or higher, and the 4-vinylguaiacol content is 60 μg / L or higher... 8. A low-alcohol beer-flavored beverage containing kwashin and components derived from de-alcoholized wort ferment. 10. The malt ratio is 50% by mass or more, the purine content is less than 2.7 mg / 100 mL, and it contains tryptophosphate... 14. The malt ratio is 50% by mass or more, the purine content is less than 2.7 mg / 100 mL, and the total polyphenols... 15 The beer-flavored beverage according to the present invention has a color of 20°EBC or higher and contains 2,3,5-trimethylpyridine...

[0107] (STEP 4: Solution Generation) Next, the control unit 104 sends solution generation instruction information to the natural language processing server 2, instructing it to generate a solution corresponding to the solution means string (second string) and the user request input string, and receives a solution string containing the solution corresponding to the request string from the natural language processing server 2. The program is as follows.

[0108] (Code block 6) # Generate answer def generate_response_gpt(text): response = client.chat.completions.create( model="gpt-4o-mini" Messages=[ {"role": "system", "content": "The following text presents 10 technological solutions related to the challenge of wanting to drink a refreshing beer! Combine these 10 solutions to create a detailed beer solution that meets the need for a refreshing beer!"} {"role": "user", "content": text}], Temperature = 0, max_tokens=5000, frequency_penalty=0, presence_penalty=0, ) solution_content = response.choices[0].message.content return solution_content solution_content = generate_response_gpt(all_solutions_combined) print(solution_content)

[0109] This program first defines a function called `generate_response_gpt`. This function generates a solution about refreshing beer based on the user's input text `text`. Inside the function, it calls the `client.chat.completions.create` method to generate a chat-style response using OpenAI's GPT-4o-mini model. This method uses the GPT-4o-mini model.

[0110] In a specific method call, the following parameters are set: - `model="gpt-4o-mini"`: Specifies GPT-4o-mini as the large-scale language model to use. - `messages`: Specifies a chat-style message list. This list contains two dictionaries. The first dictionary represents system messages and is set to the following: "The following sentences are 10 technical solutions related to the problem of wanting to drink a refreshing beer! Combine these 10 solutions to come up with a detailed beer solution proposal that meets the need for a refreshing beer!" This is an instruction message (solution generation instruction information) given to a large language. The second dictionary represents user messages and is set to the content of the `text` received as a function argument.

[0111] This method call causes the large-scale language model to generate a response based on the input message, and that response is stored in the `response` object. The generated response is retrieved via `response.choices[0].message.content` and stored in the `solution_content` variable.

[0112] Next, the generated solution is returned as the function's return value. Calling the function generates a detailed solution proposal about refreshing beer based on the input text.

[0113] Next, we show the code to display the generated solution. First, we call the `generate_response_gpt` function, passing all the pre-combined solutions (solution information) as arguments. As a result, the generated solution is stored in the `solution_content` variable. Next, we print the solution to the console using the `print` function (sending it to terminal 2 and displaying it).

[0114] Here, the `all_solutions_combined` variable is a string formed by combining 10 technical solutions related to refreshing beer, separated by spaces. This string is used as the text input to the large-scale language model and forms the basis for generating optimal solution proposals. The solution information generated by Natural Language Processing Server 2 is shown below.

[0115] (Generated solution information) Below are detailed solutions to meet the need for a refreshing beer. 1. Basic design of beer-flavored beverages - Original extract concentration: Ensures a concentration of 20.0% by mass or higher to provide a robust flavor. - Appearance of fermentation level: Set to 70.0% or higher to bring out the fruity aroma through fermentation. - Alcohol content: 1.0(v / v)% to 3.8(v / v)%, resulting in a light and easy-to-drink beer. 2. Selection of raw materials - Fermentation ingredients: Soy protein hydrolysate and alanine are used to balance the amino acids and improve the mouthfeel. - Malt ratio: Use 50% or more by mass to ensure a rich malt flavor. 3. Health-conscious ingredients - Carbohydrate concentration: Keep it below 2g / 100ml so that even those on a diet can enjoy it. - Purine concentration: Set to 2mg / 100ml or less, taking into consideration those who are health-conscious. - Alanine concentration: Within the range of 1-40 mg / 100 ml to improve palatability. 4. Adjusting the flavor - Pyroglutamine: Contains 60 mg / L or more to enhance the umami flavor. - Tryptophan: Contains 3mg / L or more to promote relaxation. - Total polyphenol content: Set to 30 mg / L or higher to provide antioxidant effects. 5. Enhance the fragrance - Contains 0.7 mg / L or more of ethyl caproate to enhance the fruity aroma. - Linalool: Contains 5 μg / L or more to create a gorgeous fragrance. - Roasted aroma: The color is set to 20°EBC or higher, and whey protein is used to enhance the roasted aroma. 6. Innovations in manufacturing methods - Adjusting the degree of fermentation by appearance: Adjust within the range of 5-80% to control the progress of fermentation. - Low-alcohol beer-flavored beverage: Alcohol content is set between 1.0(v / v)% and less than 4.5(v / v)% to appeal to a wide range of consumers. 7. How to provide - Package design: Adopt a design that evokes a sense of freshness and is visually appealing. - Suggestion for consumption: It is recommended to drink it chilled, emphasizing that it is especially ideal for refreshing oneself during the summer. In this way, to meet the demand for a refreshing beer, we combine various elements, from the selection of raw materials and manufacturing methods to the adjustment of aroma and taste, to propose a beer-flavored beverage that is both health-conscious and satisfying to drink.

[0116] The subsequent evaluation process and specification preparation process are the same as in the first embodiment, so their explanation will be omitted.

[0117] The above describes the second embodiment. This method makes it possible to efficiently generate and display solutions related to refreshing beer. According to this embodiment, since a solution is generated by combining the means of solving a patent application that has a problem close to the user's needs (user request input string), it becomes possible to generate a technically feasible and concrete solution proposal, and it also becomes possible to create a draft specification based on it.

[0118] (Third embodiment) In the second embodiment, the degree of association between the question string and the task string was determined by processing with a large-scale language model, but in the second embodiment, it is determined by processing with an embedding model. Note that the processing common to the second embodiment (STEP 1, 3, and 4) is omitted from the description.

[0119] (STEP 2': Assessment of relevance to the issue) The control unit 104 sends the task string information and user needs string information to the natural language processing server 2 and receives the task string vector and user needs string vector from the natural language processing server 2. Next, the control unit 104 calculates the task string vector and user needs string vector and stores them in a data frame. The program is as follows.

[0120] (Code block 7) import numpy as np from scipy.spatial.distance import cosine # Function for embedding def get_embedding(text, model="text-embedding-3-small"): text = text.replace("\n", " ") return client.embeddings.create(input = [text], model=model).data[0].embedding # Vectorization of the question question_vec = get_embedding('I want to drink a refreshing beer!') # Vectorizing the problem # Add the results of the embedding process to a new column (problem_vec) df['problem_vec'] = df['problem'].apply(lambda x: get_embedding(x)) # Calculate cosine similarity and store it in the problem_similarity column. df['problem_similarity'] = df['problem_vec'].apply(lambda x: 1 - cosine(question_vec, x))

[0121] This code block uses vectorization of text data and calculation of cosine similarity to assess the relevance of issues related to a specific question.

[0122] First, this invention imports the cosine distance calculation functions of the NumPy and SciPy libraries. This provides a foundation for performing numerical calculations and similarity calculations between vectors.

[0123] Next, we define a function `get_embedding` that performs the embedding process to convert text into a vector. This function converts the input text into a vector using the specified model.

[0124] The detailed processing of the `get_embedding` function is as follows: 1. Text preprocessing: Replace newline characters (`\n`) in the input text with spaces. 2. Vectorization: The preprocessed text is vectorized using the specified embedding model (default is `text-embedding-3-small`). This is done by using the `client.embeddings.create` method to input the text into the embedding model and returning the resulting vector.

[0125] Next, the specific question sentence "I want to drink a refreshing beer!" is vectorized. The aforementioned `get_embedding` function is used for this vectorization process, and the result is stored in the `question_vec` variable.

[0126] Next, each problem in the data frame `df` is vectorized, and the result is stored in a new column `problem_vec`. This process uses the `apply` method to apply the `get_embedding` function to each problem.

[0127] Next, the cosine similarity between each problem vector and the question vector is calculated and stored in the `problem_similarity` column. The `cosine` function from the SciPy library is used to calculate the cosine similarity. Specifically, the `apply` method is used to calculate the cosine similarity between each problem vector and the question vector, and the relevance is obtained by subtracting this value from 1.

[0128] This code block, through the series of processes described above, makes it possible to evaluate the similarity of each issue to a specific question and store the results in a data frame. This lays the foundation for identifying the issues most relevant to the question and effectively suggesting solutions. A portion of the problem_similarity column, when converted into a data frame, is shown below.

[0129] (Data in the problem_similarity column) 0 0.522902429 1 0.507360655 2 0.397344891 3 0.467611204 4 0.437586373 ... 95 0.384736783 96 0.374925549 97 0.468733117 98 0.512744404 99 0.376991651

[0130] As described above, in this embodiment, by combining solutions to problems extracted from numerous patents that are close to the user's requested input string, it becomes possible to generate new product solution proposals and thus conceive concrete product solutions.

[0131] In this embodiment, the string categories (a pair of first and second strings) are defined as problem and solution, but the method is not limited to this. Any two categories such as benefit, quality, application, effect, problem, solution, needs, function, configuration, mechanism, and parts may be extracted as pairs to generate a solution. For example, a pair of "needs (first string)" and "function (second string)" may be extracted, and a function may be extracted from a technology that has needs related to the user's request input string to generate a new solution. Alternatively, a pair of "part (first string)" and "effect (second string)" may be extracted, and a new product solution may be generated by combining the effects brought about by a specific part.

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

[0133] (Invention 7) An idea generation support program that causes a computer to perform the following processes: extracting a pair of first and second strings from each of a plurality of strings relating to a specific object; converting each of the plurality of first strings and a request input string indicating a user's request for the specific object into vector data using an embedding model to obtain a first string vector and a request input string vector; calculating the vector similarity between the first string vector and the request input string vector; identifying the first string corresponding to the first string vector whose similarity satisfies predetermined conditions, and extracting the second string that is paired with the identified first string; inputting the extracted second string and solution generation instruction information instructing the generation of a solution corresponding to the request input string to a large-scale language model, and obtaining the output of a solution string corresponding to the request input string from the large-scale language model.

[0134] (Invention 8) An idea generation support method in which a computer performs the following processes: extracting a pair of first and second strings from each of a plurality of strings relating to a specific object; converting each of the plurality of first strings and a request input string indicating a user's request for the specific object into vector data using an embedding model to obtain a first string vector and a request input string vector; calculating the vector similarity between the first string vector and the request input string vector; identifying the first string corresponding to the first string vector whose similarity satisfies predetermined conditions, and extracting the second string that is paired with the identified first string; inputting the extracted second string and solution generation instruction information instructing the generation of a solution corresponding to the request input string to a large-scale language model, and obtaining an output of a solution string corresponding to the request input string from the large-scale language model.

[0135] (Invention 9) The idea generation support program according to claim 7 or 8, characterized in that the similarity is the cosine similarity between the first string vector and the requested input string vector. [Explanation of Symbols]

[0136] 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, The process involves inputting multiple information strings relating to a predetermined subject and problem analysis instruction information, which includes instructions to perform an analysis on a predetermined subject-specific product based on the multiple information strings, into a large-scale language model, and obtaining an output of an analysis result string from the large-scale language model. The process involves inputting the multiple information strings and solution generation instruction information that instructs the generation of solutions corresponding to the analysis result strings into the large-scale language model, and obtaining the output of solution strings corresponding to the analysis result strings from the large-scale language model. An idea generation support program that helps you implement ideas.

2. On the computer, A process for extracting a pair of first and second strings from each of several strings relating to a predetermined subject, The process involves inputting into a large-scale language model the degree of association between each of the plurality of first strings and the request input string indicating the user's request for the specific target, and obtaining an output of the degree of association between each of the plurality of first strings and the request input string from the large-scale language model. The process involves extracting a first string having a degree of relevance above a predetermined level from the plurality of first strings, and extracting a second string that is paired with the extracted first string. The process involves inputting the extracted second string and solution generation instruction information that instructs the generation of a solution corresponding to the request input string into the large-scale language model, and obtaining an output of a solution string corresponding to the request input string from the large-scale language model. An idea generation support program that helps you implement ideas.

3. The process involves inputting the solution string and patent specification generation instruction information that instructs the generation of patent specification information corresponding to the solution string into the large-scale language model, and obtaining an output of a patent specification string corresponding to the solution string from the large-scale language model. The idea generation support program according to claim 1 or 2, further enabling the execution of the following.

4. The idea generation support program according to claim 1 or 2, which further causes the large-scale language model to be populated with the solution string and evaluation instruction information that instructs the evaluation of the solution string, and to obtain an evaluation string of the solution string from the large-scale language model.

5. Computers The process involves inputting multiple information strings relating to a predetermined subject and analysis instruction information, which includes instructions to perform an analysis on a predetermined subject-specific product based on the multiple information strings, into a large-scale language model, and obtaining an output of an analysis result string from the large-scale language model. The process involves inputting the multiple information strings and solution generation instruction information that instructs the generation of solutions corresponding to the analysis result strings into the large-scale language model, and obtaining the output of solution strings corresponding to the analysis result strings from the large-scale language model. A method for supporting idea generation to implement this.

6. Computers A process for extracting a pair of first and second strings from each of several strings relating to a predetermined subject, The process involves inputting into a large-scale language model the degree of association between each of the plurality of first strings and the request input string indicating the user's request for the specific target, and obtaining an output of the degree of association between each of the plurality of first strings and the request input string from the large-scale language model. The process involves extracting a first string having a degree of relevance above a predetermined level from the plurality of first strings, and extracting a second string that is paired with the extracted first string. The process involves inputting the extracted second string and solution generation instruction information that instructs the generation of a solution corresponding to the request input string into the large-scale language model, and obtaining an output of a solution string corresponding to the request input string from the large-scale language model. A method for supporting idea generation to implement this.

Images