Idea support program and method

Abstract

To provide an idea support method. [Solution] The computer is caused to perform the following processes: using a large-scale language model or an embedded model, evaluating the similarity between each of a plurality of strings related to a specific product and a user request input string; extracting strings having a predetermined high similarity from the plurality of strings; and using the large-scale language model, generating a solution corresponding to the user request input string from the extracted strings.

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 performed by performing morphological analysis of natural language sentences. However, when morphological analysis is performed, the context is lost, and it is necessary for a human being to reconstruct the relationship after that.

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

[0006] The present invention is an idea generation support program that causes a computer to execute the following processes: using a large-scale language model or an embedded model, a process of evaluating the similarity between each of a plurality of strings related to a specific product and a user request input string; a process of extracting strings having a predetermined high similarity from the plurality of strings; and a process of generating a solution corresponding to the user request input string from the extracted strings using the large-scale language model. Effect of the Invention

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

[0008] [Figure 1] Schematic diagram of a system for executing an idea support method [Diagram 2] Terminal block diagram [Diagram 3] Flowchart of the idea support program DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

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

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

[0011] The natural language processing server 2 is a computer that executes processing of character strings made of input natural language (in the embodiment, similarity evaluation processing and solution generation processing). The natural language processing server of the embodiment is a natural language processing server that provides a cloud-based service incorporating large-scale language models such as OpenAI's GPT-4o, GPT-4o-mini, GPT-4 Turbo, and GPT-4 (all of which 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, Anthropic's Claude3 Opus, Claude3.5 Sonnet).

[0012] The natural language processing server 2 is a computer that executes vectorization (embedding processing) of an input character string. The natural language processing server 2 of the embodiment is a natural language processing server that provides a cloud-based service 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 a natural language processing server that provides a natural language processing service incorporating an embedding model that provides a similar function.

[0013] 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 an input from an external device, and outputs the natural language processing.

[0014] 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, similarity evaluation processing and solution generation processing), and outputs the result.

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

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

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

[0018] The ROM 102 prestores programs and thresholds executed by the CPU 101. The RAM 103 has various memory areas, such as an area for loading the programs executed by the CPU 101 and a work area that serves as a work area for data processing by the programs.

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

[0020] 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 may be a network interface for communication via a wired or wireless network.

[0021] The control unit 104 exchanges data with an external device (natural language processing server) via the external I / F 106 to extract highly similar product-related strings, send instruction information, and receive generated results such as similarity evaluation information, embedded information, and solution means information.

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

[0023] (First embodiment) The processing procedure of the program of the idea support method of the first embodiment will be described. In the embodiment, the idea support is performed for beer, but the target product is not limited to this. The series of code blocks below are the program and method of the embodiment. However, for ease of explanation, the program and method will be divided into code blocks and explained.

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

[0025] 3 is a flowchart of the process of the idea generation support processing program of the embodiment. In STEP 1, the similarity between each of a plurality of character strings (here, the text of the abstract) (information character strings related to a specific product) and a user request input character string input by the user is evaluated, in STEP 2, one or more information character strings with high similarity are extracted, and in STEP 3, a solution corresponding to the user request input character string input by the user is generated from the extracted information character strings.

[0026] In the embodiment, an abstract of patent data on beer is used as a product-related information character string in natural language related to a specific product, but the subject of the information character string is not limited to this, and may be a character string in the main text of the specification or in the claims. In addition, character strings in natural language from questionnaires, user reviews, papers, etc. other than patent data may also be processed.

[0027] (STEP 1: Similarity evaluation) The control unit 104 extracts text from abstracts of multiple patent data related to a specific product (multiple information character strings related to a specific product). The program is as follows. The following program is run on a Python (Registered Trademark)This is a program by. However, it is not limited to this, and other programming tools and programming languages ​​(VBA, GAS, etc.) may be used. Also, the following program is only an example, and the processing order, libraries, functions, and variable names used may be changed.

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

[0029] The program is explained as follows. First, the control unit 104 imports a module called pandas. pandas is a Python (Registered Trademark) It is a tool for data analysis. Next, import the function drive from the module google.colab. drive is a function for accessing Google Drive. Google is a registered trademark.

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

[0031] 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, and CSV format is also possible if other functions are used). This Excel file stores patent data that contains multiple abstract data (information strings). This patent data is patent data related to beer. When generating new beer solutions, the patent data related to beer is used. A portion of the summary column of the patent data converted into a data frame is shown below.

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

[0033] The abstract column of the data frame stores the contents of the patent abstract. Note that in the above example, due to space limitations, only the first five and a portion of the last five are shown, but in the embodiment, a data frame of 100 items (100 rows) is used. Of course, more or less than this number is possible. Also, in the above example, due to space limitations, the full text of the abstract is not displayed in the abstract column, but in reality the full text of the abstract is stored in one cell in Excel. Note that Excel is a registered trademark. Note that columns other than the abstract column will be added to the data frame by the processing in the following steps.

[0034] The control unit 104 assigns the read file to a variable called df. df is a table-format data structure called a data frame. By specifying df['Summary'], only the column called "Summary" is extracted from df. The content of the patent abstract written in natural language is stored in the summary column.

[0035] Next, the control unit 104 transmits the information string, the user request input string, and similarity evaluation instruction information (string similarity evaluation instruction information) to the natural language processing server 2, and receives similarity evaluation information (string similarity evaluation information) from the natural language processing server 2. The program is as follows.

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

[0037] This command is a Python command for OpenAI. (Registered Trademark) It is for installing libraries. The ! indicates that the command should be interpreted as a shell command. pip is a Python (Registered Trademark) In the package manager, install is the command used to install a library.

[0038] The control unit 104 uses Python called openai. (Registered Trademark) Import the library. The openai library is used to perform various natural language processing tasks using the OpenAI API. Note that to use the openai library, you actually need to enter an API key, but this is omitted from the program description because it would be a hindrance to making it public.

[0039] Next, the control unit 104 transmits the character string, the user request input character string, and similarity evaluation instruction information to the natural language processing server 2, and receives similarity evaluation information from the natural language processing server 2. The program is as follows.

[0040] (Code Block 3) # Determining similarity between assignments and questions 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 to the sentence "I want to drink a refreshing beer!" using human sense and show 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, ) similarity = response.choices[0].message.content return similarity

[0041] This program uses OpenAI's language model "GPT-4o-mini" to provide the function of summarizing a given sentence. Note that the language model is not limited to "GPT-4o-mini", but may be "GPT-4 Turbo" or other companies' large-scale language models, or the next version of the GPT series. These are known to demonstrate high accuracy in natural language processing tasks.

[0042] generate_similarity_gpt(text) receives one text (text) as an argument, and the control unit 104 calls the Chat Completion API of OpenAI to evaluate the similarity of that text. The API sends a message consisting of two roles, that of the system and the user, and sends instruction information (prompt) from the system side saying, "Please judge the similarity between the content of the following sentence and the sentence 'I want to drink a refreshing beer!' using human senses, and indicate it as a percentage. Please output only the percentage value." This instruction information is the similarity evaluation instruction information.

[0043] The similarity evaluation instruction information also includes user request input character string information from the user, such as "I want to drink a refreshing beer!". The user request input character string information from the user may be a request in any natural language of the user. The output is not limited to a percentage, but may be other numerical expressions or expressions in natural language such as large, medium, small, high, low, etc. The point is that it is sufficient to be able to express the magnitude of similarity by comparing them.

[0044] The natural language processing server 2 evaluates the given text (character string information) based on the similarity evaluation instruction information and returns the similarity evaluation information. The response from the natural language processing server 2 includes the evaluated percentage (similarity evaluation information). The similarity evaluation information is stored in the similarity variable and returned as the output of the function.

[0045] (Code Block 4) # Add the result of the similarity evaluation to a new column (similarity) df['similarity'] = df['summary'].apply(lambda x: generate_similarity_gpt(x))

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

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

[0048] (similarity column data) 0 70 1 70 2 10 3 70 4 30 .. ... 95 20 96 20 97 30 98 70 99 30

[0049] (STEP 2: Extract strings) Next, the control unit 104 extracts one or more information character strings (abstracts) of patent applications having high similarity, and generates combined character string information. The program is as follows.

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

[0051] This part of the program first removes the percent sign (%) from the 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 similarity column using the str.rstrip('%') method, and then converts it to a floating point type using the astype('float') method.

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

[0053] Next, select only the summary columns from the data frame top_10_similarity extracted above, and store the selected summary columns in a new series top_10_solutions. Then, use the tolist method to extract the top_10_solutions series from Python (Registered Trademark) Convert it into a list of .

[0054] 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 spaces. This combined string is stored in a new variable, all_solutions_combined.

[0055] The data for the top_10_solutions series is shown below (note that only a portion of the beginning of the information string is displayed). In this way, abstracts of highly similar patent applications are extracted. Note that in the embodiment, 10 abstracts of highly similar patent applications 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 similarity level (for example, a similarity level of 70%) or higher. If expressed as large, medium, and small, it is also possible to extract large, for example.

[0056] (Data from top_10_solutions) 15 [Abstract][Problem] The present invention relates to a beer-flavored beverage with enhanced roasted aroma, a method for producing a beer-flavored beverage, and... 44 [Abstract][Problem] To develop a beer that has the taste of wheat typical of beer and also has a refreshing and easy-to-drink taste... 63 [Abstract][Problem] The astringent taste that is unsuitable for beer-flavored beverages is suppressed, and the refreshing citrus aroma is suitable... 84 [Abstract][Problem] The present invention provides a fermented beer-flavored beverage that has a refreshing taste and is satisfying to drink... 20 [Abstract][Problem] A new beer-flavored beverage that provides the stimulating sensation typical of a beer-flavored beverage has been developed... 22 [Abstract][Problem] We would like to develop a new beer-flavored beverage that has a full-bodied taste that is characteristic of beer-flavored beverages. 23 [Abstract][Problem] A beer that has a good taste derived from barley, a good mouthfeel, and suppresses undesirable wateriness... 30 [Abstract][Problem] The present invention provides a fermented beer-flavored beverage that is refreshing and satisfying to drink... 43 [Abstract][Problem] A beer-flavored beverage that provides a refreshing taste while still providing the stimulating sensation of alcohol... 45 [Abstract][Problem] A low-alcohol beverage with reduced sweetness, rich yet crisp taste, and excellent refreshing feeling after drinking...

[0057] (STEP 3: Solution generation) Next, the control unit 104 transmits the information string information and the solution generation instruction information to the natural language processing server 2, and receives the solution information from the natural language processing server 2. The program is as follows.

[0058] (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 are 10 sentences about technology related to the requirement "I want to drink a refreshing beer!". Combine these 10 sentences to come up with a detailed solution proposal for beer that meets the need for "I want to drink 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_solution recommend_solution = generate_response_gpt(all_solutions_combined) print(recommend_solution)

[0059] This program first defines a function called `generate_response_gpt`, which generates a solution about 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.

[0060] The concrete method invocation 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 the following content is set: "The following text is a list of 10 solutions related to the requirement "I want to drink a refreshing beer!" Please combine these 10 solutions to come up with a detailed solution proposal for beer that meets the need "I want to drink a refreshing beer!" This is an instruction message (solution generation instruction information) to be given to the large-scale language. The second dictionary represents user messages, and the `text` received as an argument to the function is set as the content as is.

[0061] 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_solution` variable.

[0062] The generated solution is then returned as the function's return value. The function call generates a detailed solution proposal for a refreshing beer based on the input text.

[0063] The following code shows how to display the generated solution. First, the `generate_response_gpt` function is called, and all previously combined solutions (solution information) are passed as arguments. As a result, the generated solution is stored in the `recommend_solution` variable. Next, the solution information is displayed on the console using the `print` function (sent to terminal 2 and displayed).

[0064] Here, the `all_solutions_combined` variable is a string that combines 10 technical summaries about refreshing beer, separated by spaces. This string is used as the input text for the large-scale language model, and is the basis for generating optimal solution proposals. The solution information generated by the natural language processing server 2 is shown below.

[0065] (generated solution information) To meet the needs of people who want to drink refreshing beer, we came up with the following detailed solution proposals: This beer aims to be both refreshing and satisfying. 1. Basic characteristics of beer-flavored beverages - Color: 20°EBC or higher, resulting in a visually beautiful beer. - Alcohol content: less than 4.0 (v / v)%, giving it a light feel. - Appearance fermentation degree: 70.0% or more, to give depth of flavor through fermentation. 2. Taste ingenuity - Malt ratio: 5% to less than 100% malt is used, allowing you to fully enjoy the malt flavor. - Carbohydrate content: 2.0g / 100mL or less, with a moderate sweetness and refreshing taste. - Fructose, glucose, and maltose concentration: Set the total concentration to 3.0 mg / mL or more to make the drink satisfying to drink. 3. Aroma enhancement - Citrus scent: Contains 1.0μg / L or more of ingredients including linalool oxide, geranyl acetate, and β-citronellol, enhancing the refreshing scent. - Enhanced roasted aroma: Whey protein is used to enhance the roasted aroma, adding a fragrant flavor. 4. Health-conscious considerations - Low calorie: By limiting sugar and keeping calories low, it appeals to health-conscious consumers. - Richness and sharpness: Reduces sweetness while providing richness and enhances the refreshing feeling after drinking. 5. Manufacturing method - Fermentation process: Using beer yeast, the apparent fermentation degree is set to 105.0% or more, which gives the beer a pungent, beer-like taste. - Method for enhancing roasted aroma: Whey protein is added to the raw materials and a process is introduced to enhance the roasted aroma. 6. Summary To achieve a refreshing yet satisfying taste, this beer-flavored beverage has been designed to preserve the flavor of the barley while reducing sugar and enhancing the citrus aroma. It is also a low-calorie product that takes health-conscious consumers into consideration, and aims to provide a refreshing feeling after drinking. This will meet the needs of those who want to enjoy a refreshing beer.

[0066] The above is an embodiment. This method makes it possible to efficiently generate and display technical solutions related to refreshing beer. According to the embodiment, a solution is generated by combining abstracts (information strings) of patent applications that are close to the user's needs (user request input strings), so it is possible to generate concrete solution proposals that are highly technically feasible.

[0067] Second embodiment In the first embodiment, the similarity between the question string and the summary 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 2 and 3) common to the first embodiment will be omitted.

[0068] (STEP 1´: Similarity evaluation) The control unit 104 transmits the character string information and the user needs character string information to the natural language processing server 2, and receives the character string vector and the user needs character string vector from the natural language processing server 2. Next, the control unit 104 obtains the character string vector and the user needs character string vector, and stores them in a data frame. The program is as follows.

[0069] (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!') # Vectorize the summary # Add the embedding result to a new column (summary_vec) df['summary_vec'] = df['summary'].apply(lambda x: get_embedding(x)) # Calculate the cosine similarity and store it in the similarity column df['similarity'] = df['summary_vec'].apply(lambda x: 1 - cosine(question_vec, x))

[0070] This block of code uses vectorization of text data and cosine similarity calculations to evaluate the similarity of summaries relevant to a particular question.

[0071] First, in the present 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 vector similarity calculations.

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

[0073] 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: Vectorize the preprocessed text using the specified embedding model (`text-embedding-3-small` by default), by inputting the text into the embedding model using the `client.embeddings.create` method, and returning the resulting vector.

[0074] Next, the specific question "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.

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

[0076] Next, we calculate the cosine similarity between each summary vector and the question vector, and store the results in the `similarity` column. To calculate the cosine similarity, we use the `cosine` function from the SciPy library. Specifically, we use the `apply` method to calculate the cosine similarity between each summary vector and the question vector, and subtract the value from 1 to obtain the similarity.

[0077] In this code block, the above process allows us to evaluate the similarity of each abstract to a given question and store the results in a data frame. This will lay the foundation for identifying the most relevant abstracts to the question and effectively suggesting solutions. A portion of the similarity column in a data frame is shown below.

[0078] (similarity column data) 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

[0079] Thereafter, as described above, in STEP 2, one or more highly similar information strings are extracted, and in STEP 3, a solution corresponding to the user request input string input by the user is generated from the extracted information strings.

[0080] As described above, in the embodiment, new product solution proposals are generated by combining information strings extracted from multiple patents that are close to the user's requested input string, making it possible to come up with concrete product solutions.

[0081] 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 new embodiment can be implemented in various other forms, and various omissions, substitutions, and modifications can be made without departing from the gist of the invention. This embodiment and its modifications are included in the scope and gist of the invention, and are included in the scope of the invention and its equivalents described in the claims. [Explanation of symbols]

[0082] 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 inputting, into a large-scale language model, each of a plurality of information character strings extracted from a document related to a specific product and similarity evaluation instruction information including an instruction for evaluating a similarity between each of the plurality of information character strings and a request character string indicating a user's request for the specific product, and obtaining an output of a similarity between each of the plurality of information character strings and the request character string from the large-scale language model; A process of extracting information character strings having a similarity degree equal to or higher than a predetermined value from the plurality of information character strings, and combining the extracted information character strings having a similarity degree equal to or higher than the predetermined value into one input character string; a process of inputting the input character string and solution generation instruction information for instructing generation of a solution corresponding to the requested character string to the large-scale language model, and obtaining an output of a solution corresponding to the requested character string from the large-scale language model; An idea support program that helps you execute your ideas.

2. On the computer, inputting each of a plurality of information strings extracted from documents relating to a particular product into an embedding model and obtaining an output of a vector for each of the plurality of information strings from the embedding model; inputting a requirement string indicating a user's requirement for the particular product into the embedding model, and obtaining an output of a vector of the requirement string from the embedding model; calculating a similarity between a vector of each of the plurality of information character strings and a vector of the request character string; A process of extracting information character strings having a similarity degree equal to or higher than a predetermined value from the plurality of information character strings, and combining the extracted information character strings having a similarity degree equal to or higher than the predetermined value into one input character string; a process of inputting the input character string and solution generation instruction information for instructing generation of a solution corresponding to the requested character string to a large-scale language model, and obtaining an output of a solution corresponding to the requested character string from the large-scale language model; An idea support program that helps you execute your ideas.

3. The computer a process of inputting, into a large-scale language model, each of a plurality of information character strings extracted from a document related to a specific product and similarity evaluation instruction information including an instruction for evaluating a similarity between each of the plurality of information character strings and a request character string indicating a user's request for the specific product, and obtaining an output of a similarity between each of the plurality of information character strings and the request character string from the large-scale language model; A process of extracting information character strings having a similarity degree equal to or higher than a predetermined value from the plurality of information character strings, and combining the extracted information character strings having a similarity degree equal to or higher than the predetermined value into one input character string; a process of inputting the input character string and solution generation instruction information for instructing generation of a solution corresponding to the requested character string to the large-scale language model, and obtaining an output of a solution corresponding to the requested character string from the large-scale language model; A method for supporting ideas.

Images