Idea generation support program and methods

Abstract

We provide methods to support idea generation. [Solution] The computer is made to perform the following processes: evaluate the similarity between each of a plurality of strings relating to a specific product and a user request input string using a large-scale language model or an embedded model; extract strings having a predetermined high similarity from the plurality of strings; and generate a solution corresponding to the user request input string from the extracted strings using the large-scale language model.

Description

Technical Field

[0007]

[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 Document

Patent Document

[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 to support ideas. However, when morphological analysis is performed, 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 aims to support ideas.

Means for Solving the Problems

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

Effects of the Invention

[0007] According to the idea support method and program of the present invention, ideas can be supported. [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 [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] The natural language processing server 2 is a computer that processes a string of natural language input (in this embodiment, similarity evaluation processing and solution generation processing). The natural language processing server in this embodiment is a cloud-based service that incorporates a large-scale language model such as OpenAI's GPT-4o, GPT-4o-mini, GPT-4 Turbo, and GPT-4 (all API services). However, the natural language processing server 2 is not limited to these, and any generative AI server that performs natural language processing incorporating a large-scale language model that provides similar functionality (for example, Google's Gemini or Anthropic's Claude3 Opus and Claude3.5 Sonnet) would suffice.

[0012] Natural Language Processing Server 2 is a computer that performs vectorization (embedding) of an input string. In this embodiment, Natural Language Processing Server 2 is a cloud-based service provider that incorporates an embedding model such as OpenAI's text-embedding-3-small, text-embedding-3-large, or text-embedding-ada-002 (all API services). However, Natural Language Processing Server 2 is not limited to these, and may be a Natural Language Processing Server that provides a Natural Language Processing service incorporating an embedding model that provides similar functionality.

[0013] The natural language processing server 2 of this embodiment receives input from an external device, performs natural language processing (embedding processing in this embodiment) incorporating an embedding model, and outputs the result.

[0014] 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 (similarity evaluation processing and solution generation processing in this embodiment) incorporating a large-scale language model on input from an external device and outputs the result.

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

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

[0017] 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 CPU 101, the ROM 102, and the RAM 103 constitute a control unit 104.

[0018] The ROM 102 stores in advance programs and threshold values 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 programs.

[0019] 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 an external device such as an external server (PC).

[0020] The external I / F 106 may be any interface that performs 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 communicating 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 product-related character strings with high similarity, transmit instruction information, and receive generation results such as similarity evaluation information, embedding 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. The input unit 107 is an input device such as a keyboard, a mouse, or a scanner (reading device).

[0023] (First Embodiment) The processing procedure of the program for the idea generation support method of the first embodiment will be described. Note that in this embodiment, idea generation support is provided for beer, but the target product is not limited to beer. The following series of 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.

[0024] In the program for the idea generation support method of the first 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 similar abstract strings (information strings) from patent data and generates a solution from these strings 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.

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

[0026] In this embodiment, a summary of patent data related to beer is used as the product-related information string consisting of natural language concerning a predetermined product. However, the information string is not limited to this and may also be a string within the text of the specification or a claim. Furthermore, strings consisting of natural language other than patent data, such as questionnaires, user reviews, or academic papers, may also be used as the target of processing.

[0027] (STEP 1: Similarity assessment) 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.

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

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

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

[0031] 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 (information strings) stored within it. 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.

[0032] (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. ...

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

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

[0035] Next, the control unit 104 sends the information string, the user request input string, and the similarity evaluation instruction information (string similarity evaluation instruction information) to the natural language processing server 2, and receives the 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 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.

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

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

[0040] (Code block 3) # Determining the similarity 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, ) similarity = response.choices[0].message.content return similarity

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

[0042] 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 similarity 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 output only the percentage value." This prompt is used as the similarity evaluation prompt.

[0043] Furthermore, the similarity evaluation instruction information includes user request input string information, such as "I want to drink a refreshing beer!". Note that the user request input string information can be any natural language request from the user. Also, the output is not limited to percentages; it can be other numerical expressions, or natural language expressions such as large, medium, small, high, or low. The point is that it should be able to compare and express the degree of similarity.

[0044] The natural language processing server 2 evaluates the given text (string information) based on the similarity evaluation instruction information and returns it as 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 similarity evaluation results to a new column (similarity). df['similarity'] = df['summary'].apply(lambda x: generate_similarity_gpt(x))

[0046] This part of the program is designed to evaluate the text in each row stored in the 'Summary' column of the Pandas dataframe df using the generate_similarity_gpt function, and add the result (similarity evaluation information) to a new column 'similarity' in df.

[0047] The `generate_similarity_gpt` function receives formatted text and evaluates it using the GPT-4o-mini model. The evaluation result (percentage of similarity) is stored in a new column 'similarity' in the dataframe `df`. A portion of the dataframe containing the similarity column is shown below. In this embodiment, similarities 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.

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

[0049] (STEP 2: String Extraction) Next, the control unit 104 extracts one or more patent application information strings (abstracts) with high similarity and generates combined string information. The program is as follows:

[0050] (Code block 5) # Remove '%' from the similarity column and convert 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 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)

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

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

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

[0054] 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`.

[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. In this embodiment, 10 abstracts of highly similar patent applications 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 similarity (for example, a similarity of 70%) or higher may be extracted. If expressed as large, medium, or small, for example, only the large ones may be extracted.

[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, ... 44 [Summary] [Challenge] To create a beer that has a characteristic malty flavor and a clean, easy-to-drink taste... 63 [Summary] [Problem] The astringency unsuitable for beer-flavored beverages is suppressed, and a pleasant citrus-like refreshing aroma is achieved... 84 [Abstract] [Problem] The present invention provides a fermented beer-flavored beverage that has a clean taste while also being satisfying to drink... 20 [Summary] [Problem] A novel beer-flavored beverage that provides the stimulating sensation characteristic of beer-flavored beverages is needed... 22 [Summary] [Challenge] To create a novel beer-flavored beverage that offers a full-bodied taste characteristic of beer... 23 [Summary] [Problem] The malt-derived flavor is good, it has a satisfying mouthfeel, and the undesirable wateriness is suppressed... 30 [Abstract] [Problem] The present invention aims to provide a fermented beer-flavored beverage that has a clean taste while still being satisfying to drink... 43 [Summary] [Problem] In beer-flavored beverages, while still providing the stimulating sensation derived from alcohol, it is also possible to achieve a refreshing taste... 45 [Summary] [Problem] A low-alcohol beverage with suppressed sweetness, rich body, a clean finish, and excellent refreshing aftertaste...

[0057] (STEP 3: Solution Generation) Next, the control unit 104 sends information string information and solution generation instruction information to the natural language processing server 2, and receives 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 technical sentences related to the desire to drink a refreshing beer! Combine these 10 sentences to come up with a detailed solution for a beer that meets the need 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 recommended_solution recommend_solution = generate_response_gpt(all_solutions_combined) print(recommend_solution)

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

[0060] 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 solutions related to the request 'I want to drink a refreshing beer!'. Combine these 10 solutions to come up with a detailed beer solution proposal that meets the need 'I want to drink 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 `text` received as a function argument.

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

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

[0063] 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 `recommend_solution` variable. Next, we print the solution information to the console using the `print` function (sending it to terminal 2 and displaying it).

[0064] Here, the `all_solutions_combined` variable is a string formed by combining 10 technical summaries about 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.

[0065] (Generated solution information) To meet the demand for a refreshing beer, we have devised the following detailed solution. This beer aims to achieve both a refreshing taste and a satisfying drinking experience. 1. Basic characteristics of beer-flavored beverages - Color: Achieves a visually appealing beer with a color intensity of 20°EBC or higher. - Alcohol content: Less than 4.0(v / v)%, giving it a light feel. - Visible fermentation level: 70.0% or higher, to give depth through fermentation. 2. Flavor improvements - Malt ratio: Uses 5% to less than 100% malt, allowing you to fully enjoy the flavor of the malt. - Carbohydrate content: kept below 2.0g / 100mL, resulting in a less sweet and refreshing taste. - Fructose, glucose, and maltose concentrations: The total concentration should be set to 3.0 mg / mL or higher to provide a satisfying taste. 3. Enhance the fragrance - Citrus scent: Contains 1.0 μg / L or more of ingredients including linalool oxide, geranyl acetate, and β-citronellol to enhance the refreshing scent. - Enhanced roasted aroma: By using whey protein, the roasted aroma is enhanced, adding a savory flavor. 4. Health-conscious considerations - Low calorie: By reducing sugar content and keeping calories low, it appeals to health-conscious consumers. - Richness and crispness: While keeping the sweetness in check, it has a rich flavor and enhances the refreshing feeling after drinking. 5. Manufacturing method - Fermentation process: Brewer's yeast is used, and the visible fermentation level is set to 105.0% or higher. This gives it a characteristic beer-like kick. - Method to enhance roasted aroma: Incorporate a process that adds whey protein to the raw materials to enhance the roasted aroma. 6. Summary This beer-flavored beverage balances refreshing taste with a satisfying body by preserving the flavor of malt while reducing sugar content and enhancing the citrus aroma. It also caters to health-conscious consumers, being low in calories while still providing a refreshing aftertaste. This allows it to meet the needs of those who want to enjoy a refreshing beer.

[0066] The above describes the embodiment. This method makes it possible to efficiently generate and display technical solutions related to refreshing beer. According to the embodiment, since a solution is generated by combining a patent application summary (information string) that is close to the user's needs (user request input string), it is possible to generate a specific solution proposal that is technically feasible.

[0067] (Second Embodiment) In the first embodiment, the similarity between the question string and the summary 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 first embodiment (STEP 2 and 3) is omitted from the description.

[0068] (STEP 1': Similarity evaluation) The control unit 104 sends the string information and user needs string information to the natural language processing server 2 and receives the string vector and user needs string vector from the natural language processing server 2. Next, the control unit 104 calculates the string vector and user needs 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 # 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!') # Vectorization of summaries # Add the results of the embedding process to a new column (summary_vec) df['summary_vec'] = df['summary'].apply(lambda x: get_embedding(x)) # Calculate cosine similarity and store it in the similarity column. df['similarity'] = df['summary_vec'].apply(lambda x: 1 - cosine(question_vec, x))

[0070] This code block evaluates the similarity of summaries related to a specific question using vectorization of text data and calculation of cosine similarity.

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

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

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

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

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

[0076] Next, the cosine similarity between each summary vector and the question vector is calculated and stored in the `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 summary vector and the question vector, and the similarity is obtained by subtracting this value from 1.

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

[0078] (Data in the 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

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

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

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

[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 that uses a large-scale language model or embedding model to evaluate the similarity between each of several information strings related to a specific product and a user request input string. A process for extracting information strings having a predetermined degree of similarity from the aforementioned plurality of information strings, Using the aforementioned large-scale language model, a process is performed to generate a solution corresponding to the user request input string from the extracted information string, An idea generation support program that helps you implement ideas.

2. Computers A process that uses a large-scale language model or embedding model to evaluate the similarity between each of several information strings related to a specific product and a user request input string. A process for extracting information strings having a predetermined degree of similarity from the aforementioned plurality of information strings, Using the aforementioned large-scale language model, a process is performed to generate a solution corresponding to the user request input string from the extracted information string, A method for supporting idea generation to implement this.

Images