Idea support program and method

Abstract

To provide an idea support method.SOLUTION: Extracting, from each of a plurality of pieces of character string information related to a specific product, an issue character string and a solution character string that are paired with each other, evaluating, using a large-scale language model or an embedding model, a degree of association between each of the plurality of issue character strings and a user request input character string, extracting, from the plurality of issue character strings, an issue character string having a predetermined high degree of association and extracting a solution character string paired with the extracted issue character string, and generating, using the large-scale language model, a concept corresponding to the user request input character string based on the extracted solution character string.SELECTED DRAWING: Figure 3

Description

[Technical Field]

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

[0002] Patent Document 1 discloses an idea generation support method. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Patent No. 7117044 Summary of the Invention [Problem to be solved by the invention]

[0004] In Patent Document 1, idea generation support is provided by performing morphological analysis of natural language sentences. However, when morphological analysis is performed, the relationship between the problem and the solution is separated, and therefore the relationship must be reconstructed by a human being.

[0005] The present invention has been made to solve such conventional problems, and aims to support idea generation. [Means for solving the problem]

[0006] The present invention is an idea generation support program that causes a computer to execute the following processes: a process of extracting paired first and second character strings from each of a plurality of character strings related to a specific target; a process of inputting, into a large-scale language model, each of the plurality of first character strings and relevance evaluation instruction information including instructions for evaluating the relevance between each of the plurality of first character strings and a request input string indicating a user's request for the specific target, and obtaining an output of the relevance between each of the plurality of first character strings and the request input string from the large-scale language model; a process of extracting, from the plurality of first character strings, first character strings having a relevance equal to or higher than a predetermined level, and extracting a second character string that pairs with the extracted first character string; and a process of inputting, into the large-scale language model, the extracted second character string and concept generation instruction information that instructs the generation of a concept corresponding to the request input string, and obtaining an output of a concept corresponding to the request string from the large-scale language model.

[0007] The present invention is an idea generation support method in which a computer executes the following processes: a process of extracting a pair of first and second character strings from each of a plurality of character strings related to a specific target; a process of inputting, into a large-scale language model, each of the plurality of first character strings and relevance evaluation instruction information including instructions for evaluating the relevance between each of the plurality of first character strings and a request input string indicating a user's request for the specific target, and obtaining an output of the relevance between each of the plurality of first character strings and the request input string from the large-scale language model; a process of extracting, from the plurality of first character strings, first character strings having a relevance equal to or higher than a predetermined level, and extracting a second character string that pairs with the extracted first character string; and a process of inputting, into the large-scale language model, the extracted second character string and concept generation instruction information that instructs the generation of a concept corresponding to the request input string, and obtaining an output of a concept corresponding to the request string from the large-scale language model. [Effects of the Invention]

[0008] According to the idea generation support program and method of the present invention, it is possible to support idea generation. [Brief explanation of the drawings]

[0009] [Figure 1]Schematic diagram of a system for executing an idea generation support method [Figure 2] Terminal block diagram [Figure 3] Flowchart of idea support program DETAILED DESCRIPTION OF THE INVENTION

[0010] Hereinafter, an idea generation support program and method according to an embodiment will be described in detail with reference to the drawings.

[0011] 1 is a schematic diagram of a system for executing a method for supporting idea generation. To execute the method for supporting idea generation, a terminal 1 is connected to a natural language processing server 2 via a network.

[0012] The natural language processing server 2 is a computer that processes character strings composed of input natural language (in the embodiment, performs relevance evaluation processing and concept generation processing). The natural language processing server of the embodiment is a natural language processing server that provides a cloud-based service incorporating a large-scale language model, for example, OpenAI's GPT series (GPT-4o, GPT-4o-mini, GPT-4 Turbo, GPT-4, etc.) (all of these are API services). Note that the natural language processing server 2 is not limited to this, and may be any generation AI server that executes natural language processing incorporating a large-scale language model that provides similar functions (for example, Google's Gemini series or Anthropic's Claude series).

[0013] In the embodiment, natural language processing is performed on the server 2 side, but it may also be performed on the terminal 1 side. There are various large-scale language models that can be executed on the terminal 1, such as Gemma (so-called local LLM). In this case, the server 2 is not required.

[0014] The natural language processing server 2 is a computer that performs vectorization (embedding processing) of input character strings. The natural language processing server 2 of the embodiment is a natural language processing server that provides cloud-based services incorporating embedding models such as OpenAI's text-embedding-3-small, text-embedding-3-large, and text-embedding-ada-002 (all of which are API services). Note that the natural language processing server 2 is not limited to this, and may be any natural language processing server that provides natural language processing services incorporating embedding models that provide similar functions.

[0015] The natural language processing server 2 of the embodiment executes natural language processing incorporating an Embedding model (embedding processing in the embodiment) in response to input from an external device, and outputs the result.

[0016] The natural language processing server 2 of the embodiment has a CPU, memory, input / output devices, and an external interface, and performs natural language processing incorporating a large-scale language model in response to input from an external device (in the embodiment, relevance evaluation processing and concept generation processing) and outputs the results.

[0017] In the embodiment, natural language processing is performed on the server side, but it may also be performed on the terminal 1 side. Embedding models that can be executed on terminal 1 include Word2Vec, GloVe, FastText, and BERT. There are also various large-scale language models that can be executed on terminal 1. In this case, the natural language processing server 2 is not required.

[0018] 2 is a block diagram of a terminal 1 in a system for executing an idea generation support program and method according to an embodiment. The terminal is, for example, a personal computer, tablet, smartphone, or the like owned by a user.

[0019] 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 via a system bus 108. The CPU 101, the ROM 102, and the RAM 103 constitute a control unit 104.

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

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

[0022] The external I / F 106 may be any interface that performs data communication with an external device, and may be, for example, a device (such as a USB memory) that connects locally to the external device, or a network interface for communication via a wired or wireless network.

[0023] The control unit 104 exchanges data with an external device (natural language processing server) via the external I / F 106 to extract problems and solutions, extract highly related problems, send instruction information, and receive generated results such as relatedness evaluation information, embedded information, and solution information.

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

[0025] (First embodiment) The processing procedure of the program for the idea generation support method of the first embodiment will be explained. Note that in this embodiment, idea generation support is provided for beer, but the target product is not limited to this. The series of code blocks 1 to 6 below are the program and method of the embodiment. However, for ease of explanation, the code blocks 1 to 6 will be divided and explained below.

[0026] In the program for the idea generation support method of the first embodiment, solutions that have related problems are extracted from patent data in response to a user's request for a product (user request input string: "I want to drink a refreshing beer!"), and a solution concept that satisfies the user's request input string for a product is generated from these solutions. Note that the user request input string is not limited to this, and can be any request for beer.

[0027] 3 is a flowchart of the process of the idea generation support processing program of the embodiment. In STEP 1, a plurality of problem character strings (first character strings) and a plurality of solution character strings (second character strings) that are paired with each other are extracted from a plurality of abstracts (a plurality of character strings related to a specific product) of patent data related to a predetermined product. In STEP 2, the degree of relevance between each of the plurality of problem character strings (first character strings) and a user request input character string entered by a user is evaluated. In STEP 3, one or more solution character strings (second character strings) that correspond (are paired) with the problem character string (first character string) that has a high degree of relevance are extracted. In STEP 4, a concept corresponding to the user request input character string entered by the user is generated based on the extracted solution character strings (second character strings).

[0028] In the embodiment, a summary of patent data on beer is used as a character string in natural language related to a predetermined product, but the subject of the character string is not limited to this and may be a character string in the main text of a specification or a claim.Furthermore, character strings in natural language from surveys, user reviews, papers, etc. other than patent data may also be processed.

[0029] (STEP 1: Identifying issues and solutions) First, the control unit 104 extracts a problem string (first string) and a corresponding solution string (second string) from the abstracts of multiple patent data (multiple strings related to a specific product). The program is as follows: The following program is written in Python (registered trademark, the same applies below) and stored in the control unit of the terminal 1. However, this is not limited to this, and other programming tools and programming languages ​​(VBA, GAS, etc.) may also be used. The following program is merely an example, and the processing order and the libraries, functions, and variable names used may be changed.

[0030] (Code Block 1) import pandas as pd # Loading data # Using Google Drive from google.colab import drive drive.mount(' / content / drive') # Load data (from Google Drive) df = pd.read_excel(' / content / drive / MyDrive / beer_patent.xlsx') # Separating the problem from the solution # Extract the strings between [Problem] and [Solution], and between [Solution] and [Selection diagram], and add them as new columns (problem,solution) df['problem'] = df['summary'].str.extract('[problem](.+?)[solution]', expand=False) # Create a 'solution' column df['solution'] = df['Summary'].str.extract('[Solution](.+?)(?:[Choice]|$)', expand=False)

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

[0032] The control unit 104 executes the drive function to mount Google Drive to the path ' / content / drive'. Mounting means that files and folders in Google Drive can be operated on Google Colab.

[0033] The control unit 104 uses the pd.read_excel function to read the Excel file beer_patent.xlsx located in the path ' / content / drive / MyDrive / beer_patent.xlsx' (note that the file format is not limited to Excel; CSV format is also possible if other functions are used). This Excel file stores patent data containing multiple abstract data (character string data in natural language). This patent data is patent data related to beer. When generating new beer concepts, beer-related patent data is used. A portion of the summary column of the patent data converted into a data frame is shown below.

[0034] (Summary column data) [Summary][Challenge] Achieving a beer-like flavor and rich taste while reducing purine concentration... 1 [Abstract][Problem] Achieving a beer-like flavor and rich taste while reducing purine concentration... 2 [Abstract][Problem] Providing a beer-flavored beverage with reduced residual flavors. 3 [Summary][Problem] How to make beer that contains 50% or more malt by mass, yet has no off-flavors derived from barley... 4 [Summary][Issue] Malt content is 50% or more and sugar content is 0.5g / 100g... .. ... ... ... 95 [Abstract][Challenge] To provide a beer-flavored beverage with an excellent balance of richness and crispness. 96 [Abstract][Problem] A method for producing a non-fermented beer-flavored beverage, in which the concentration of DMTS is confirmed... 97 [Abstract][Problem] The present invention provides a means for reducing the astringency of beer-flavored beverages,... 98 [Abstract][Problem] Providing a non-alcoholic beer-flavored beverage with a firm flavor. 99 [Abstract][Problem] To provide a beer-like sparkling beverage with reduced carbon dioxide loss.

[0035] The abstract column of the data frame stores the contents of the patent abstract. Note that, due to space constraints, the above example only shows the first five and a portion of the last five patents, but in this embodiment, a data frame with 100 patents (100 rows) is used. Of course, more or less than this number is possible. Also, due to space constraints, 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. Columns other than the abstract column will be added to the data frame by the processing in the following steps.

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

[0037] The control unit 104 uses the str.extract function to extract the string from "Problem" to "Solution" from the summary column. This string represents the patent problem (this is called problem string information). The extracted string is added to a new column called "problem." A new column called "problem" is created in df by setting df['problem'] = ...

[0038] Similarly, the control unit 104 uses the str.extract function to extract the string from "Solution" to "Selection Diagram" from the summary column. This string represents the solution of the patent (referred to as solution string information). The extracted string is added to a new column called "solution." A new column, "solution," is created in df by setting df['solution'] = .... A portion of the problem column and solution column converted into a data frame is shown below. Note that due to space constraints, only the first five and a portion of the last five items are shown below, but in this embodiment, a data frame with 96 items (96 rows) is used. Also, due to space constraints, the problem column and solution column do not display the full text above, but in reality, the full text of the problem and solution is stored in one cell each in Excel.

[0039] (data in the problem column) A beer-flavored fermented alcohol that has a reduced purine concentration while still retaining the richness and flavor of beer... 1. A beer-flavored fermented alcohol that has a reduced purine concentration while still retaining the richness and flavor of beer... 2. Providing a beer-flavored beverage with reduced residual flavor. 3. Low-carb beer with an improved crispness of barley-derived off-flavors, despite containing 50% or more malt by mass... 4. Malt content is 50% or more, sugar content is 0.5g / 100ml or less, and yet the beer has a sweet taste. .. ... 95 To provide a beer-flavored beverage with an excellent balance of richness and crispness. 96 A manufacturing method for a non-fermented beer-flavored beverage that can reliably reduce the concentration of DMTS, and the method 97 The present invention provides a means for reducing the astringency of beer-flavored beverages and improving their mildness. 98. Providing a non-alcoholic beer-flavored beverage with a firm taste. 99 To provide a beer-like sparkling beverage in which carbon dioxide loss is suppressed.

[0040] (solution column data) A beer-flavored fermented alcoholic beverage with a reduced purine concentration, which contains the original extract... 1. A beer-flavored fermented alcoholic beverage with a reduced purine concentration, in which the molecular weight of the beverage is 20 to 100... 2. The malt content of 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 malt content of the raw materials is 50% by mass or more, sugar is included as an ingredient, and the sugar content of beer-flavored beverages is... 4. The malt content of 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 an apparent final fermentation degree of 89% or more, and have an amino acid concentration of... 96 A method for producing a non-fermented beer-flavored beverage includes heating a sugar solution at a pH of 4.0 or higher in a copper-containing vessel. 97 The present invention relates to an agent for improving the astringency of beer-flavored beverages, and... 98 Weight ratio of polyphenols to total extract (weight % of polyphenols / weight % of total extract) 99 Beer-like sparkling beverage characterized by containing polyglycerol fatty acid ester and linalool, Poly...

[0041] In the embodiment, the character strings "Problem" and "Solution" are extracted from the abstract using regular expressions, but this is not limited to this. For example, the entire abstract (or a specific part or the entire specification) can be sent as character string information to the natural language processing server, and the natural language processing server's large-scale language model can extract the problem and solution (in this case, the natural language processing server generates a pair of problem (first character string) and solution (second character string)). However, by extracting the character strings "Problem" and "Solution" separately from the abstract, the usage fee and processing time of the generation AI can be reduced, and the processing accuracy of the subsequent process by the natural language processing server 2 can be improved, so it is preferable to include a process for extracting the character strings "Problem" and "Solution".

[0042] (STEP 2: Evaluation of relevance to the issue) Next, the control unit 104 transmits each of the multiple task character strings (first character strings) and task relevance evaluation instruction information (relevance evaluation instruction information) including an instruction to evaluate the relevance between each of the multiple task character strings and a request input character string indicating a user's request for a specific target to a natural language processing server 2 having a large-scale language model, and receives task relevance evaluation result information (first character string relevance evaluation result information) including an output of the relevance between each of the multiple task character strings and the request input character string from the natural language processing server 2. The program is as follows.

[0043] (Code Block 2) # Installing packages ! pip install openai import openai

[0044] This command installs the OpenAI Python library. The ! indicates that the command should be interpreted as a shell command. pip is a Python package manager, and install is the command used to install libraries.

[0045] The control unit 104 imports a Python library called openai. The openai library is used to execute various natural language processing tasks using the OpenAI API. Note that, although input of an API key is actually required to use the openai library, this is omitted from the program description because it would be difficult to make it public.

[0046] Next, the control unit 104 transmits the task string and task relevance evaluation instruction information including an instruction to evaluate the relevance with 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.

[0047] (Code Block 3) # Determine the relevance of the assignment and question def generate_similarity_gpt(text): response = client.chat.completions.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": "Please judge the similarity of the content of the following sentence with the sentence "I want to drink a refreshing beer!" using human sense, and indicate it as a percentage. Please output only the percentage value. "}, {"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

[0048] This program uses OpenAI's language model "GPT-4o-mini" to provide the ability to summarize given text. Note that the language model is not limited to "GPT-4o-mini," but can also be "GPT-4 Turbo," a large-scale language model from another company, or the next version of the GPT series. These are known to demonstrate high accuracy in natural language processing tasks.

[0049] generate_similarity_gpt(text) receives one 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, one for the system and one for the user, and the system sends instruction information (prompt) saying, "Please use your human senses to determine the similarity between the content of the following sentence and the sentence, 'I want to drink a refreshing beer!' and indicate it as a percentage. Please output only the percentage value." This instruction information is used as task relevance evaluation instruction information.

[0050] The task relevance evaluation instruction information also includes a user request input string from the user, such as "I want to drink a refreshing beer!". The user request input string from the user can be a request in any natural language of the user, but it goes without saying that the accuracy of the answer will be higher if the user input string is a question with content similar to the task of beer. The output is not limited to a percentage, and can be other numerical expressions or natural language expressions such as large, medium, small, high, and low. The key is to be able to express the degree of relevance by comparing their magnitudes.

[0051] 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 including the relevance between the problem string and the user request string. The response from the natural language processing server 2 includes a numerical value (problem relevance evaluation result information) of the evaluated percentage. The problem relevance evaluation result information is stored in the problem_similarity variable and returned as the output of the function.

[0052] (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))

[0053] This part of the program evaluates each row of text stored in the 'problem' column of the Pandas data frame df using the generate_similarity_gpt function, and adds the results (problem relevance evaluation result information) to a new column 'problem_similarity' in df.

[0054] The generate_similarity_gpt function receives the formatted text and evaluates it using the GPT-4o-mini model. The evaluation results (relevance percentage) are stored in a new column 'problem_similarity' in the data frame df. A portion of the problem_similarity column converted to a data frame is shown below. In this embodiment, relevance levels of 10 to 80% were obtained. Note that due to space constraints, only the first five and a portion of the last five results are shown below, but in this embodiment, a data frame with 100 results (100 rows) is used. Of course, more or less than this number of results is possible.

[0055] (data in the problem_similarity column) 0 70 1 70 2 10 3 70 April 30 .. ... 95 20 96 20 97 30 98 70 99 30

[0056] (STEP 3: Extract solution) Next, the control unit 104 extracts problem strings whose relevance to the problem is equal to or greater than a predetermined level, extracts solution strings (second strings) of patent applications that are paired with these problems, and generates solution string information. The program is as follows.

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

[0058] This part of the program first removes the percent sign (%) from the problem_similarity column of the data frame df and converts it to a numeric type (floating point type). 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 type using the astype('float') method.

[0059] Next, we extract the top 10 rows with the largest values ​​in the problem_similarity column using the nlargest method, and store the extracted top 10 rows in a new data frame called top_10_similarity.

[0060] Next, select only the solution column from the data frame top_10_similarity extracted above, store the selected solution column in a new series top_10_solutions, and then use the tolist method to convert the top_10_solutions series to a Python list.

[0061] The converted list is stored in a new variable, solutions_list. Then, using the join method, each string in solutions_list is joined into one long string, separated by a space. This combined string is stored in a new variable, all_solutions_combined.

[0062] The data for the top_10_solutions series is shown below (note that only a portion of the solutions at the top is displayed). In this way, solutions for patent applications with highly similar problems are extracted. In the embodiment, 10 patent applications with highly related problems are extracted, but it is also possible to extract more or less than 10 depending on the evaluation policy. It is also possible to extract patent applications with a predetermined degree of relatedness (for example, a degree of relatedness of 70%) or higher.

[0063] (data from top_10_solutions) 44 Original extract concentration is 20.0% by mass or more, apparent fermentation degree is 70.0% or more, and alcohol content is... 46 Contains soy protein hydrolysate and alanine as fermentation ingredients, with a carbohydrate concentration of 2g / 100ml or less and 2mg... 0 The alcohol content is between 1.0 (v / v)% and 3.8 (v / v)% and the content of pyroglutamic acid is... 1 Malt ratio is 50% or more but less than 100% by mass, and the alcohol content is 1.0% (v / v) or more but less than 4.5%... 3. The alcohol content is 10% or more (v / v), the ethyl caproate content is 0.7mg / L or more, and the... 5. The alcohol content is 10% or more v / v and the 4-vinylguaiacol content is 60 μg / L or more. 8. A low-alcohol beer-flavored beverage containing ingredients derived from quartz and dealcoholized wort fermentation liquid. 10 Malt ratio is 50% or more by mass, purine content is less than 2.7 mg / 100 mL, and tryptophan is not contained... 14 Malt ratio is 50% or more by mass, purine content is less than 2.7 mg / 100 mL, and total polyphenols are... 15 The beer-taste beverage of the present invention has a color of 20°EBC or more and contains 2,3,5-trimethylpyrazine.

[0064] (STEP 4: Concept generation) Next, the control unit 104 transmits the solution means string (second string) and concept generation instruction information instructing the natural language processing server 2 to generate a concept corresponding to the user request input string, and receives a concept string including a concept corresponding to the request string from the natural language processing server 2. The program is as follows.

[0065] (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 lists 10 solutions related to the technology needed to create a refreshing beer. By combining these 10 solutions, you will come up with a detailed concept for a beer that meets the need for a refreshing beer."}, {"role": "user", "content": text}], temperature=0, max_tokens=5000, frequency_penalty=0, presence_penalty=0, ) recommend_solution = response.choices[0].message.content return recommend_concept recommend_concept = generate_response_gpt(all_solutions_combined) print(recommend_concept)

[0066] This program first defines a function called `generate_response_gpt`, which generates a concept for a 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.

[0067] The specific method call sets the following parameters: - `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 content: "The following text lists 10 technological solutions related to the challenge of "I want to drink a refreshing beer!". Please combine these 10 solutions to come up with a detailed concept proposal for a beer that satisfies the need for "I want to drink a refreshing beer!"." This is an instruction message (concept generation instruction information) given to the large-scale language. The second dictionary represents user messages and is set to the `text` received as an argument to the function.

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

[0069] The generated concept is then returned as the function's return value, which generates a detailed concept proposal for a refreshing beer based on the input text.

[0070] The following code shows how to display the generated concepts. First, the `generate_response_gpt` function is called, and all pre-bound concepts (concept information) are passed as arguments. As a result, the generated concepts are stored in the `recommend_concept` variable. Next, the concepts are displayed on the console using the `print` function (sent to terminal 2 and displayed).

[0071] Here, the `all_solutions_combined` variable is a space-separated string of 10 technical solutions related to refreshing beer. This string is used as input text for a large-scale language model and serves as the basis for generating optimal concept proposals. The concept information generated by natural language processing server 2 is shown below.

[0072] (Generated concept information) Below we present a detailed concept proposal to meet the needs of those who want to drink refreshing beer. 1. Basic design of beer-flavored beverages - Original extract concentration: Ensure a concentration of 20.0% by mass or more to ensure a robust flavor. - Appearance fermentation level: Set to 70.0% or higher to bring out the fruity aroma of fermentation. - Alcohol content: 1.0% (v / v) to 3.8% (v / v) to create a light, easy-to-drink beer. 2. Selection of raw materials - Fermented ingredients: Soy protein hydrolysate and alanine are used to balance the amino acids, improving the drinkability. - Malt ratio: Use 50% or more by mass to ensure a strong 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 health into consideration. - Alanine concentration: 1-40mg / 100ml range for improved drinking comfort. 4. Adjust the flavor - Pyroglutamine: Contains 60mg / L or more to enhance the umami flavor. - Tryptophan: Contains 3mg / L or more, which is expected to have a relaxing effect. - Total polyphenol content: Set at 30mg / L or more to provide antioxidant properties. 5. Aroma Enhancement - Ethyl caproate: Contains 0.7mg / L or more to enhance the fruity aroma. - Linalool: Contains more than 5μg / L, creating a gorgeous fragrance. - Roasted aroma: Color is increased to 20°EBC or higher and whey protein is used to enhance the roasted aroma. 6. Innovation in manufacturing methods - Adjusting the apparent fermentation level: Adjust within the range of 5-80% to control the progress of fermentation. - Low-alcohol beer-flavored beverages: The alcohol content is set at between 1.0% (v / v) and 4.5% (v / v), appealing to a wide range of consumers. 7. How to provide - Package design: Use a refreshing design that is visually pleasing. - Drinking suggestions: We recommend drinking it chilled, highlighting that it is ideal for refreshing yourself, especially in the summer. In this way, to meet the needs of people who want to drink refreshing beer, we combine various elements, from selecting ingredients to manufacturing methods and adjusting aromas and flavors, to propose a beer-flavored beverage that is both healthy and satisfying to drink.

[0073] The above is an embodiment. This method makes it possible to efficiently generate and display concepts related to refreshing beer. According to the embodiment, concepts are generated by combining solutions from patent applications that have problems close to the user's needs (user-requested input character string), making it possible to generate concrete concept proposals that are technically highly feasible.

[0074] (Second embodiment) In the first embodiment, the relevance between the question string and the task string is calculated by processing a large-scale language model, but in the second embodiment, it is calculated by processing using an embedded model. Note that the description of the processes (STEPs 1, 3, and 4) common to the first embodiment will be omitted.

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

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

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

[0078] First, in this invention, the cosine distance calculation functions of the NumPy library and the SciPy library are imported, which prepares the foundation for performing numerical calculations and calculating the similarity between vectors.

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

[0080] The detailed processing of the function `get_embedding` 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 (`text-embedding-3-small` by default), by using the `client.embeddings.create` method to input the text into the embedding model and returning the resulting vector.

[0081] Next, the specific question "I want to drink a refreshing beer!" is vectorized. This vectorization process uses the `get_embedding` function mentioned above, and the result is stored in the `question_vec` variable.

[0082] Next, we vectorize each problem in the data frame `df` and store the result in a new column `problem_vec` by applying the `get_embedding` function to each problem using the `apply` method.

[0083] Next, we calculate the cosine similarity between each problem vector and the question vector, and store the result in the `problem_similarity` column. To calculate cosine similarity, we use the `cosine` function from the SciPy library. Specifically, we use the `apply` method to calculate the cosine similarity between each problem vector and the question vector, and then subtract this value from 1 to calculate the relevance.

[0084] In this code block, the above series of processes allows us to evaluate the similarity of each problem to a specific question and store the results in a data frame. This will identify the most relevant problems to the question and lay the foundation for effective concept proposals. A portion of the problem_similarity column converted to a data frame is shown below.

[0085] (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

[0086] As described above, in the embodiment, new product concept proposals are generated by combining solutions corresponding to issues extracted from a large number of patents that are close to the user's requested input string, making it possible to come up with concrete product concepts.

[0087] In the embodiment, the categories of character strings (pairs of first and second character strings) are set to two, namely, problems and solutions, but this is not limited thereto. Any two of the following categories may be extracted as a pair to generate a concept: benefit, quality, use, effect, problem, solution, need, function, configuration, mechanism, part, etc. For example, a pair of "needs (first character string)" and "function (second character string)" may be extracted, and a function may be extracted from a technology having a need related to the user's request input character string to generate a new concept. It is also possible to extract a pair of "parts (first character string)" and "effect (second character string)" and combine the effects brought about by a specific part to generate a new product concept.

[0088] Although the embodiment has been described above, this embodiment is presented as an example and is not intended to limit the scope of the invention. This novel embodiment can be embodied 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 modifications are included within the scope and spirit of the invention, and are also included in the inventions and their equivalents as set forth in the claims. [Explanation of symbols]

[0089] 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 process of extracting a pair of a first character string and a second character string from each of a plurality of character strings related to a specific target; a process of inputting each of the plurality of first character strings and relevance evaluation instruction information including an instruction for evaluating the relevance between each of the plurality of first character strings and a request input character string indicating a user's request for the specific target into a large-scale language model, and obtaining an output of the relevance between each of the plurality of first character strings and the request input character string from the large-scale language model; extracting first character strings having a degree of association equal to or greater than a predetermined degree from the plurality of first character strings, and extracting second character strings that are paired with the extracted first character strings; a process of inputting the extracted second character string and concept generation instruction information instructing generation of a concept corresponding to the requested input character string into the large-scale language model, and obtaining an output of the concept corresponding to the requested input character string from the large-scale language model; An idea support program that helps you implement the following.

2. The computer A process of extracting a pair of a first character string and a second character string from each of a plurality of character strings related to a specific target; a process of inputting each of the plurality of first character strings and relevance evaluation instruction information including an instruction for evaluating the relevance between each of the plurality of first character strings and a request input character string indicating a user's request for the specific target into a large-scale language model, and obtaining an output of the relevance between each of the plurality of first character strings and the request input character string from the large-scale language model; extracting first character strings having a degree of association equal to or greater than a predetermined degree from the plurality of first character strings, and extracting second character strings that are paired with the extracted first character strings; a process of inputting the extracted second character string and concept generation instruction information instructing generation of a concept corresponding to the requested input character string into the large-scale language model, and obtaining an output of the concept corresponding to the requested input character string from the large-scale language model; A method of supporting ideas.

Images