System

Abstract

A system is provided.SOLUTION: A system comprising: means for receiving a condition inputted by a user regarding a specific food ingredient; means for transmitting the received condition to a server; means for extracting a recipe from a database based on the condition; means for presenting the extracted recipe to the user; means for receiving an evaluation of the user; and means for transmitting the received evaluation to the server and updating a generated AI model.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The technology of the present disclosure relates to a system. [Background technology]

[0002] Patent document 1 discloses a persona chatbot control method performed by at least one processor, the method including the steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to a description of the chatbot character, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance in response to the user utterance. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] Many people want to avoid certain ingredients, which limits their cooking options. There are also many challenges when it comes to choosing ingredients, such as food allergies, budgetary constraints, and the need to use seasonal ingredients. These constraints can make everyday cooking monotonous, and it can be difficult to find recipes that meet individual needs. [Means for solving the problem]

[0005] The present invention provides a means for accepting input conditions for specific ingredients from a user and transmitting the conditions to a server. The server includes means for extracting recipes from a database based on the conditions and presenting the extracted recipes to the user. It also includes means for accepting user ratings, transmitting the ratings to the server, and updating the generative AI model. In this way, by presenting recipes that meet the conditions, the system can meet the needs of individual users and provide them with a diverse and enjoyable cooking experience. Furthermore, by taking into account the seasonality of ingredients and budget information, it can provide economical and environmentally friendly options.

[0006] "User" refers to an individual or organization that uses this system.

[0007] "Input conditions" refers to information entered by the user, such as specific ingredients, allergy information, budget, and seasonal ingredients.

[0008] "Server" refers to a computer system that processes input requirements received from a user and generates an appropriate recipe.

[0009] A "recipe" refers to data that includes information such as how to cook a dish, the process, and the ingredients used.

[0010] "Database" refers to a system for managing and storing recipe information and user evaluation data.

[0011] "JSON format" refers to a standard data format for representing data in a lightweight and easy-to-read format.

[0012] A "generative AI model" refers to an artificial intelligence model used to generate recipes based on user input conditions and evaluation data.

[0013] "Extraction" refers to the act of retrieving necessary information from a database based on specific conditions.

[0014] "Conditions" refer to requests and constraints that users input into the system.

[0015] "Evaluation" refers to feedback such as a score or a comment that a user gives to a presented recipe. [Brief explanation of the drawings]

[0016] [Figure 1] 1 is a conceptual diagram showing an example of the configuration of a data processing system according to a first embodiment. [Figure 2] 1 is a conceptual diagram showing an example of main functions of a data processing device and a smart device according to a first embodiment. [Figure 3] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a second embodiment. [Figure 4] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and smart glasses according to a second embodiment. [Figure 5] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a third embodiment. [Figure 6] FIG. 11 is a conceptual diagram showing an example of main functions of a data processing device and a headset-type terminal according to a third embodiment. [Figure 7] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a fourth embodiment. [Figure 8] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and a robot according to a fourth embodiment. [Figure 9] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 10] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 11] FIG. 3 is a sequence diagram showing a processing flow of the data processing system according to the first embodiment. [Figure 12] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1. [Figure 13] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system according to the second embodiment when an emotion engine is combined. [Figure 14] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 2 when an emotion engine is combined. DETAILED DESCRIPTION OF THE INVENTION

[0017] An example of an embodiment of a system according to the technology of the present disclosure will be described below with reference to the accompanying drawings.

[0018] First, the terms used in the following description will be explained.

[0019] In the following embodiments, a coded processor (hereinafter simply referred to as a "processor") may be a single arithmetic device or a combination of multiple arithmetic devices. Furthermore, a processor may be a single type of arithmetic device or a combination of multiple types of arithmetic devices. Examples of arithmetic devices include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), and an APU (Accelerated Processing Unit).

[0020] In the following embodiments, a coded RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a working memory by a processor.

[0021] In the following embodiments, the coded storage is one or more non-volatile storage devices that store various programs, various parameters, etc. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), and magnetic tapes.

[0022] In the following embodiments, a communication I / F (Interface) with a symbol is an interface including a communication processor, an antenna, etc. The communication I / F controls communication between multiple computers. Examples of communication standards applied to the communication I / F include wireless communication standards including 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), Bluetooth (registered trademark), etc.

[0023] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." In other words, "A and / or B" means that it may be only A, only B, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" is also applied when three or more things are expressed connected by "and / or."

[0024] [First embodiment]

[0025] FIG. 1 shows an example of the configuration of a data processing system 10 according to the first embodiment.

[0026] 1, a data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0027] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0028] The smart device 14 includes a computer 36, a reception device 38, an output device 40, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The reception device 38, the output device 40, and the camera 42 are also connected to the bus 52.

[0029] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0030] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0031] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54.

[0032] FIG. 2 shows an example of the main functions of the data processing device 12 and the smart device 14.

[0033] 2, in the data processing device 12, a specific process is performed by the processor 28. A specific processing program 56 is stored in the storage 32. The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific process is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0034] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0035] In the smart device 14, the processor 46 performs the reception output process. The storage 50 stores a reception output program 60. The reception output program 60 is used in conjunction with the specific processing program 56 by the data processing system 10. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0036] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0037] The system of the present invention has a user, a terminal, and a server as its main components, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients, and updating the generative AI model based on the user's evaluation.

[0038] System Overview

[0039] User operations

[0040] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, a user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "I want pumpkin as a seasonal ingredient in autumn."

[0041] Sending conditions

[0042] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, which ensures data security.

[0043] Recipe Generation

[0044] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[0045] The server generates an SQL query as follows to extract the corresponding recipes from the database:

[0046] Exclude certain ingredients (e.g. garlic, wheat)

[0047] Within your budget (e.g., under 500 yen)

[0048] Prioritize seasonal ingredients (e.g. pumpkin)

[0049] Recipe presentation

[0050] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto" is displayed.

[0051] Recipe Rating

[0052] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[0053] Submitting and reviewing your evaluation

[0054] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[0055] Specific examples

[0056] For example:

[0057] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0058] 2. The device sends these conditions to the server.

[0059] 3. The server extracts recipes such as "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto" based on the conditions and sends them to the terminal.

[0060] 4. The device displays the received recipe to the user.

[0061] 5. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[0062] 6. The device sends the evaluation data to the server.

[0063] 7. The server adds the rating to the database and updates the generative AI model.

[0064] In this way, the present invention is a system that continues to suggest appropriate recipes based on the user's input conditions and evaluations.

[0065] The processing flow will be explained below.

[0066] Step 1:

[0067] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[0068] Step 2:

[0069] The terminal converts the condition data entered by the user into JSON format. For example, the data is converted as follows:

[0070] json

[0071] {

[0072] "preferences": {

[0073] "garlic": "no",

[0074] "allergies": ["wheat"],

[0075] "budget": 500,

[0076] "season_ingredient": "pumpkin"

[0077] }

[0078] }

[0079] Step 3:

[0080] The terminal sends the converted JSON data to the server using the HTTPS protocol, which ensures that the data arrives securely at the server.

[0081] Step 4:

[0082] The server parses the received JSON data, which is then broken down into fields based on the user's input (e.g., garlic, allergies, budget, season_ingredient).

[0083] Step 5:

[0084] The server generates a database query based on the parsed data to exclude certain ingredients. For example, the following SQL query is generated:

[0085] sql

[0086] SELECT FROM recipes

[0087] WHERE NOT (ingredients LIKE '%garlic%')

[0088] AND NOT (ingredients LIKE '%wheat%')

[0089] AND total_cost <= 500

[0090] AND ingredients LIKE '%pumpkin%'

[0091] ORDER BY total_rating DESC;

[0092] Step 6:

[0093] The server executes the generated query and extracts recipes from the database that match the criteria, such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto."

[0094] Step 7:

[0095] The server converts the extracted recipe data into JSON format, for example, the following JSON data is generated:

[0096] json

[0097] {

[0098] "recipes": [

[0099] {

[0100] "title": "Pumpkin and spinach gratin",

[0101] "ingredients": ["pumpkin", "spinach", ...],

[0102] "total_cost": 450,

[0103] "rating": 4.5

[0104] },

[0105] {

[0106] "title": "Pumpkin and mushroom risotto",

[0107] "ingredients": ["pumpkin", "mushroom", ...],

[0108] "total_cost": 480,

[0109] "rating": 4.7

[0110] }

[0111] ]

[0112] }

[0113] Step 8:

[0114] The server sends the converted JSON data to the terminal.

[0115] Step 9:

[0116] The device parses the received JSON data and displays it on the user interface, such as recipe information like "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto."

[0117] Step 10:

[0118] The user selects a dish from the presented recipes and actually cooks it. After cooking, the user rates the recipe in the application (e.g., 4 out of 5 stars) and adds detailed comments.

[0119] Step 11:

[0120] The terminal converts the rating data entered by the user into JSON format. For example, the data is converted as follows:

[0121] json

[0122] {

[0123] "recipe_id": 12345,

[0124] "rating": 4,

[0125] "comment": "The pumpkin flavor was strong and delicious"

[0126] }

[0127] Step 12:

[0128] The terminal transmits the converted rating data to the server using the HTTPS protocol.

[0129] Step 13:

[0130] The server analyzes the received evaluation data and adds the evaluation information of the corresponding recipe to the database.

[0131] Step 14:

[0132] The server updates the generative AI model based on the newly received evaluation data, which enables it to propose recipes that better match the user's preferences the next time recipes are generated.

[0133] Example 1

[0134] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0135] Conventional recipe suggestion systems have difficulty responding flexibly to specific user conditions and requests, and are particularly inadequate at generating recipes that take into account food allergies, budgets, and seasonal ingredients. Furthermore, they lack a mechanism for incorporating user feedback, making it difficult to regularly provide suggestions that satisfy users.

[0136] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0137] In this invention, the server includes means for accepting input conditions for specific ingredients from a user, means for transmitting the accepted conditions to a digital device, means for extracting information from a data store based on the conditions, means for presenting the extracted information to the user, means for accepting user ratings, means for transmitting the accepted ratings to the digital device and updating the generative artificial intelligence model, and means for transmitting the extracted information using a secure communication protocol. This enables more accurate recipe suggestions that correspond to the user's conditions and allows for continuous improvement that reflects the user's ratings.

[0138] "User" refers to a person who uses the system of the present invention to input specific ingredients and conditions.

[0139] "Input conditions" refer to requirements specified by the user regarding specific ingredients, allergy information, budget, seasonal ingredients, etc.

[0140] "Digital device" refers to an electronic device that receives user input, transmits it to a server, and displays the results. Examples of such devices include smartphones and tablet devices.

[0141] "Server" refers to a central control device that queries a database based on criteria received from a user and extracts, generates, and transmits relevant information.

[0142] "Information" refers to recipes and other related data extracted from a database based on user-specified criteria.

[0143] "Data store" refers to a database or storage system for storing and managing information.

[0144] "Secure communications protocol" refers to a communications method used to preserve data confidentiality and integrity, such as HTTPS.

[0145] A "generative artificial intelligence model" refers to a machine learning model that learns from user evaluation data and reflects that knowledge in its next proposal.

[0146] "Evaluation" is feedback that a user gives to a presented recipe, and includes star ratings, comments, and the like.

[0147] The present invention is a system whose main components are the user, terminal, and server. It proposes, extracts, and displays recipes based on conditions specified by the user, such as ingredients, allergy information, budget, and seasonal ingredients, and updates the generative AI model based on the user's evaluation.

[0148] System configuration

[0149] User operations

[0150] The user launches the application and inputs specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, the user inputs conditions such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[0151] Sending condition data

[0152] The terminal converts the condition data entered by the user into JSON format and transmits it securely to the server using the HTTPS protocol, thereby ensuring the confidentiality and integrity of the data.

[0153] Recipe Generation

[0154] The server parses the received JSON data and generates a database query based on the user's input criteria. Specifically, the server creates an SQL query to extract recipes that exclude specific ingredients (e.g., garlic, wheat) and prioritize seasonal ingredients (e.g., pumpkin) within budget (e.g., under 500 yen). An example of an SQL query is shown below:

[0155] sql

[0156] SELECT FROM recipes

[0157] WHERE NOT ingredients LIKE '%garlic%'

[0158] AND NOT ingredients LIKE '%wheat%'

[0159] AND price <= 500

[0160] AND ingredients LIKE '%pumpkin%'

[0161] Recipe presentation

[0162] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays the specific recipe name, required ingredients, and cooking steps on the user interface. For example, the user might be offered recipes such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto."

[0163] Recipe Rating

[0164] Users can try the recipes presented to them and then rate them in the application. Users can also provide star ratings (e.g., 4 out of 5 stars) and feedback comments.

[0165] Sending and reflecting evaluation data

[0166] The device converts the user-entered rating data into JSON format and sends it to the server using a secure communication protocol (e.g., HTTPS). The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. At the same time, the generative AI model learns from this rating data and reflects it in the next recipe suggestions.

[0167] Specific examples

[0168] For example:

[0169] 1. The user launches the application and enters the following criteria: "I don't like garlic," "I'm allergic to wheat," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0170] 2. The device converts these conditions into JSON format and sends it to the server using the HTTPS protocol.

[0171] 3. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, converts them into JSON format, and sends them to the terminal.

[0172] 4. The device analyzes the received recipe and displays it on the user interface.

[0173] 5. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[0174] 6. The device converts the evaluation data into JSON format and sends it to the server using the HTTPS protocol.

[0175] 7. The server analyzes the received evaluation data, adds the evaluation information for the corresponding recipe to the database, and updates the generative AI model.

[0176] Example prompts for generative AI models

[0177] The user has entered "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "I want pumpkin, which is a seasonal ingredient in autumn." Please suggest a recipe based on that.

[0178] In this way, the present invention is a recipe suggestion system that suggests recipes that meet the user's requirements and is capable of continuous improvement that reflects the user's evaluations.

[0179] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0180] Step 1: User input

[0181] The user launches the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, the user might specify criteria such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn." The input data is entered into the application's form.

[0182] Input: Specific ingredients, allergy information, budget, seasonal ingredients

[0183] Output: User input data

[0184] Step 2: Sending condition data

[0185] The terminal converts the condition data entered by the user into JSON format, after which the terminal transmits the data securely to the server using the HTTPS protocol, which ensures the confidentiality and integrity of the data.

[0186] Input: User-entered data

[0187] Data processing: Convert input data into JSON format

[0188] Output: Condition data in JSON format

[0189] Step 3: Generate the recipe

[0190] The server analyzes the received JSON data and generates a database query based on the user's criteria. For example, the server creates an SQL query to search for recipes that do not contain "garlic" or "wheat," that are within a budget of 500 yen, and that use "pumpkin" as a seasonal ingredient. The server executes this SQL query to extract matching recipes from the database.

[0191] Input: Condition data in JSON format

[0192] Data processing / calculation: SQL query generation and execution

[0193] Output: Recipe data

[0194] Step 4: Present the recipe

[0195] The server converts the extracted recipe data into JSON format and sends it to the device, which then analyzes the received recipe data and displays the specific recipe name, required ingredients, and cooking steps on the user interface.

[0196] Input: Recipe data

[0197] Data processing: Convert to JSON format

[0198] Output: Recipe data in JSON format

[0199] Step 5: Evaluate the recipe

[0200] The user tries the displayed recipe and enters their rating in the application. The user can write a star rating (e.g., 4 out of 5 stars) and feedback comments. This rating data is used for subsequent processing.

[0201] Input: User's recipe rating

[0202] Output: Evaluation data

[0203] Step 6: Submit and reflect evaluation data

[0204] The device converts the user-entered rating data into JSON format and sends it to the server using a secure communication protocol (e.g., HTTPS). The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. Furthermore, the generative AI model learns from this rating data and reflects it in the next recipe suggestions.

[0205] Input: Evaluation data

[0206] Data processing: Convert to JSON format and analyze

[0207] Output: Updated recipe rating information and generative AI model

[0208] In this way, the system can tailor recipe suggestions to the user's requirements and continuously improve based on user feedback.

[0209] (Application example 1)

[0210] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0211] Conventional recipe suggestion systems only provide recipes based on the user's ingredient requirements, and lack a mechanism for using user ratings to improve the system's suggestion accuracy. Furthermore, when suggesting ingredients or recipes, links to where users can purchase the ingredients are often not provided, making it difficult to take immediate action. Furthermore, even when suggesting recipes that take seasonal ingredients or budget into consideration, such information cannot be systematically incorporated. This has prevented the system from improving user convenience and satisfaction.

[0212] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0213] In this invention, the server includes a means for accepting input conditions for specific ingredients from a user, a means for transmitting the accepted conditions to the server, a means for extracting recipes from a database based on the conditions, a means for presenting the extracted recipes to the user and displaying links where the corresponding ingredients and recipes can be purchased together, a means for accepting user ratings, and a means for transmitting the accepted ratings to the server and updating the generative AI model. This allows users to obtain recipes that meet their ingredient requirements and immediately purchase related ingredients. Furthermore, by improving the system based on user ratings, users can receive more accurate suggestions.

[0214] A "user" is a consumer who utilizes the system and provides input requirements regarding a particular food ingredient.

[0215] "Input conditions" refers to information such as specific ingredients, allergy information, budget, and seasonal ingredients that the user provides to the system.

[0216] The "server" is a central computer system that processes data based on the conditions received from the user, proposes recipes, and evaluates them.

[0217] "Means for extracting recipes from a database based on conditions" refers to the function of the server searching and extracting recipes from a database that meet the conditions provided by the user.

[0218] "Means for presenting extracted recipes to the user" refers to a function for the server to provide the extracted recipes to the user in an easy-to-view format.

[0219] "Means for displaying a link where the relevant ingredients and recipe can be purchased together" refers to a function that displays a link where the user can simultaneously purchase the recipe provided by the system and the ingredients related to it.

[0220] The "means for accepting user ratings" refers to a function that allows a user to input a rating for a recipe that they have tried.

[0221] "Means for updating the generative AI model" refers to the function of adjusting the AI ​​model based on user evaluation data and reflecting this in the next recipe suggestion.

[0222] The "JSON format" is a lightweight data exchange format for exchanging user input conditions and data between applications.

[0223] The system for implementing this invention consists primarily of a user, a terminal, and a server. The user specifies input conditions using the terminal, and the server generates and presents recipes based on those conditions. The system also improves by updating the generative AI model based on user evaluations.

[0224] Program processing explanation

[0225] 1. User operations

[0226] Users open the application and input criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal for under 500 yen," and "I want pumpkin as a seasonal ingredient in autumn." This input is based on the user's preferences and specific constraints.

[0227] 2. Submitting the conditions

[0228] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, ensuring secure data transmission.

[0229] 3. Recipe Generation

[0230] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[0231] 4. Presenting the recipe

[0232] The server extracts the relevant recipes from the database, converts the data into JSON format, and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto" is displayed, along with links to purchase the corresponding ingredients and recipes.

[0233] 5. Recipe Rating

[0234] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[0235] 6. Submitting and Reflecting Ratings

[0236] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[0237] Hardware / Software used

[0238] Device: Smartphone

[0239] Software: Commercially available browsers and dedicated applications

[0240] Server: Python, Flask (server side), SQL database

[0241] Examples of concrete examples and prompts

[0242] Examples:

[0243] The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal autumn ingredient." The device sends these criteria to the server. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the criteria and sends them to the device. The device displays the received recipes to the user, along with links to purchase related ingredients. The user makes "Pumpkin and spinach gratin" and rates it four stars. The device sends the rating data to the server, which adds the rating to a database and updates the generative AI model.

[0244] Example prompt sentence:

[0245] "Please suggest recipes based on specific ingredient conditions entered by the user. The conditions are: I don't like garlic, I have a wheat allergy, the cost is under 500 yen per meal, and pumpkin is a seasonal ingredient in autumn."

[0246] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0247] Step 1:

[0248] Users launch the smartphone application and input criteria such as specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, users might input criteria such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn."

[0249] (Input) Condition data entered by the user

[0250] (Output) Prepare smartphone device for data transmission

[0251] Step 2:

[0252] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, ensuring data security during this process.

[0253] (Input) Condition data entered by the user (text format)

[0254] (Output) JSON format data sent to the server

[0255] Step 3:

[0256] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[0257] (Input) Condition data in JSON format received by the server

[0258] (Output) Generated SQL query

[0259] Step 4:

[0260] The server uses the generated SQL query to extract the corresponding recipes from the database. The extracted recipe information includes details such as the recipe name, ingredients, and cooking instructions.

[0261] (Input) Generated SQL query

[0262] (Output) Recipe information extracted from the database

[0263] Step 5:

[0264] The server converts the extracted recipe into JSON format and sends it to the terminal using the HTTPS protocol.

[0265] (Input) Recipe information extracted from the database

[0266] (Output) JSON format recipe data sent to the device

[0267] Step 6:

[0268] The device parses the JSON-formatted recipe data received from the server and displays it in a user interface, including the recipe name, ingredient list, detailed instructions, and links to purchase the associated ingredients and recipe.

[0269] (Input) JSON format recipe data received from the server

[0270] (Output) Recipe information and purchase link displayed in the user interface

[0271] Step 7:

[0272] Users try the displayed recipes and provide a rating within the application, including a star rating (e.g., 4 out of 5 stars) and detailed comments.

[0273] (Input) User rating data (star ratings and comments)

[0274] (Output) Prepare smartphone device for data transmission

[0275] Step 8:

[0276] The terminal converts the evaluation data entered by the user into JSON format and sends it to the server again using the HTTPS protocol.

[0277] (Input) User evaluation data (text format)

[0278] (Output) JSON formatted rating data sent to the server

[0279] Step 9:

[0280] The server analyzes the received evaluation data and adds the corresponding recipe evaluation information to the database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[0281] (Input) JSON formatted rating data received by the server

[0282] (Output) Evaluation information and updated generative AI model added to the database

[0283] Furthermore, an emotion engine that estimates the user's emotion may be combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59 and perform identification processing using the user's emotion.

[0284] The system of the present invention has as its main components the user, a terminal, a server, and an emotion engine, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients and their emotional state, and updating the generative AI model based on the user's evaluation of these recipes.

[0285] System Overview

[0286] User operations

[0287] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, the user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn." At the same time, data (images, voice, text, etc.) can be input at the same time for the emotion engine to analyze the user's emotions.

[0288] Sending Conditions and Emotion Data

[0289] The device converts the condition data and emotion data entered by the user into JSON format and sends it to the server using the HTTPS protocol, thereby ensuring data security.

[0290] Recipe Generation

[0291] The server analyzes the received JSON data and generates a database query based on the conditions entered by the user. The emotion engine also analyzes the provided emotion data to understand the user's current emotional state. For example, if the user is feeling stressed, the generative AI model is adjusted to suggest recipes appropriate for that emotional state (such as recipes using ingredients with a relaxing effect). Specifically, the SQL query is generated as follows:

[0292] Exclude certain ingredients (e.g. garlic, wheat)

[0293] Within your budget (e.g., under 500 yen)

[0294] Prioritize seasonal ingredients (e.g. pumpkin)

[0295] Consider ingredients that correspond to your emotional state (e.g., ingredients that have a relaxing effect)

[0296] Recipe presentation

[0297] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto" is displayed. In addition, information related to the user's emotional state is also presented.

[0298] Recipe Rating

[0299] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[0300] Submitting and reviewing your evaluation

[0301] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected the next time a recipe is generated. The emotion engine also uses the user's evaluation data to improve the accuracy of its emotional state analysis.

[0302] Specific examples

[0303] For example:

[0304] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0305] 2. The user uses a facial recognition camera to input their current emotional state (e.g., feeling stressed).

[0306] 3. The device sends the condition data and emotion data to the server.

[0307] 4. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, and prioritizes recipes with a relaxing effect based on the analysis results of the emotion engine.

[0308] 5. The extracted recipe is sent to the terminal and displayed to the user.

[0309] 6. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[0310] 7. The device sends the evaluation data to the server.

[0311] 8. The server adds the rating to the database and updates the generative AI model and emotion engine.

[0312] In this way, the present invention is a system that suggests appropriate recipes according to the user's input conditions and emotional state.

[0313] The processing flow will be explained below.

[0314] Step 1:

[0315] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[0316] Step 2:

[0317] Users input their current emotional state using an emotion-detecting camera and microphone. The emotion-detecting camera analyzes the user's facial expressions, and the microphone analyzes the user's vocal tone.

[0318] Step 3:

[0319] The device converts the condition data and emotion data entered by the user into JSON format. An example of the converted data is as follows:

[0320] json

[0321] {

[0322] "preferences": {

[0323] "garlic": "no",

[0324] "allergies": ["wheat"],

[0325] "budget": 500,

[0326] "season_ingredient": "pumpkin"

[0327] },

[0328] "emotion": {

[0329] "stress_level": "high",

[0330] "mood": "anxious"

[0331] }

[0332] }

[0333] Step 4:

[0334] The terminal sends the converted JSON data to the server using the HTTPS protocol, which ensures that the data arrives securely at the server.

[0335] Step 5:

[0336] The server parses the received JSON data, which is then broken down into fields based on the user's input (e.g., garlic, allergies, budget, season_ingredient) and emotional states (e.g., stress_level, mood).

[0337] Step 6:

[0338] The server generates a database query based on the parsed data to exclude certain ingredients. For example, the following SQL query is generated:

[0339] sql

[0340] SELECT FROM recipes

[0341] WHERE NOT (ingredients LIKE '%garlic%')

[0342] AND NOT (ingredients LIKE '%wheat%')

[0343] AND total_cost <= 500

[0344] AND ingredients LIKE '%pumpkin%'

[0345] ORDER BY total_rating DESC;

[0346] Step 7:

[0347] The server uses an emotion engine to evaluate the user's emotional state and prioritizes ingredients and recipes that have a relaxing effect. The emotion engine prioritizes recipes that contain ingredients that reduce stress (e.g., chamomile, lavender).

[0348] Step 8:

[0349] The server executes the generated query and extracts recipes from the database that match the criteria, such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto."

[0350] Step 9:

[0351] The server converts the extracted recipe data into JSON format, for example, the following JSON data is generated:

[0352] json

[0353] {

[0354] "recipes": [

[0355] {

[0356] "title": "Pumpkin and spinach gratin",

[0357] "ingredients": ["pumpkin", "spinach", ...],

[0358] "total_cost": 450,

[0359] "rating": 4.5,

[0360] "emotion_suitability": "high"

[0361] },

[0362] {

[0363] "title": "Pumpkin and mushroom risotto",

[0364] "ingredients": ["pumpkin", "mushroom", ...],

[0365] "total_cost": 480,

[0366] "rating": 4.7,

[0367] "emotion_suitability": "medium"

[0368] }

[0369] ]

[0370] }

[0371] Step 10:

[0372] The server sends the converted JSON data to the terminal.

[0373] Step 11:

[0374] The device parses the received JSON data and displays it in the user interface. For example, it displays recipe information such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto," as well as information related to the user's emotional state (e.g., "highly relaxing").

[0375] Step 12:

[0376] The user selects a dish from the presented recipes and actually cooks it. After cooking, the user rates the recipe in the application (e.g., 4 out of 5 stars) and enters detailed comments.

[0377] Step 13:

[0378] The device converts the rating data entered by the user into JSON format and sends it to the server. For example, the data is converted as follows:

[0379] json

[0380] {

[0381] "recipe_id": 12345,

[0382] "rating": 4,

[0383] "comment": "The pumpkin flavor was strong and delicious",

[0384] "emotion_feedback": {

[0385] "relaxation_effect": "high",

[0386] "mood_improvement": "significant"

[0387] }

[0388] }

[0389] Step 14:

[0390] The server analyzes the received evaluation data and adds the evaluation information of the corresponding recipe to the database.

[0391] Step 15:

[0392] The server updates the generative AI model and emotion engine based on the newly received evaluation data, allowing it to propose recipes that better match the user's emotional state and preferences the next time recipes are generated.

[0393] Example 2

[0394] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0395] In today's lifestyles, users often find it difficult to find suitable recipes that take into account ingredients, allergies, budgets, and seasonal ingredients. Taking the user's emotional state into account would also enable more satisfying recipe suggestions, but this has been difficult to achieve with conventional systems. Furthermore, the lack of a feedback function that reflects the user's evaluation of the recipe and improves the next suggestions means that user satisfaction does not improve over the long term.

[0396] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0397] In this invention, the server includes means for accepting user input conditions, means for transmitting the conditions to the server, means for generating a database query, means including an emotion engine for adjusting recipes based on the user's emotional state, means for extracting recipes from the database based on the conditions and the emotional state, means for presenting recipes to the user, means for accepting user ratings, and means for transmitting the ratings to the server and updating the generative AI model. This makes it possible to propose appropriate recipes based on the user's input conditions and emotional state, and realizes system improvements based on ratings.

[0398] A "user" is a person who uses this system to input ingredients and conditions, and makes recipe suggestions and evaluations.

[0399] "Input conditions" is information that allows the user to specify specific ingredients, allergy information, budget, seasonal ingredients, and the like.

[0400] The "server" is a central processing unit that processes the received information, generates database queries, extracts recipes, runs the emotion engine, and collects and processes rating data.

[0401] A "database query" is a query statement that the server generates to extract recipes that meet the user's requirements from the database.

[0402] The "Emotion Engine" is a system that analyzes the user's emotional state and suggests recipes that are appropriate for that state.

[0403] A "recipe" is a cooking instruction manual that includes information such as ingredients, steps, and cooking time.

[0404] "Evaluation" refers to the act of a user providing feedback on a presented recipe in the form of a star rating, a comment, or the like.

[0405] A "generative AI model" is an artificial intelligence model that suggests and adjusts recipes based on the data it receives.

[0406] The system of this invention has as its main components the user, a terminal, a server, and an emotion engine, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients and their emotional state, and for updating the generative AI model based on the user's evaluation of these recipes.

[0407] First, the user opens the application and inputs criteria such as a specific food ingredient (e.g., pumpkin), allergy information (e.g., garlic dislike, wheat allergy), budget (e.g., under 500 yen), and seasonal ingredients (e.g., pumpkin in autumn). The user also uses an input device such as a camera or microphone to input their current emotional state (e.g., feeling stressed). This information is captured by the application as text input, image, or voice data.

[0408] Next, the device converts the condition data and emotion data entered by the user into JSON format. This process is performed by the data conversion module. The converted data is sent to the server using the HTTPS protocol. Using the HTTPS protocol encrypts the data and maintains security.

[0409] The server analyzes the received JSON data and generates a database query based on the conditions entered by the user. The server's internal SQL query generation module generates an appropriate query based on the request. The emotion engine also analyzes the provided emotion data (e.g., image recognition, voice recognition) to understand the user's current emotional state. Based on this information, the generative AI model filters recipes that match the user's emotions.

[0410] For example, the following SQL query is generated: SELECT FROM recipe WHERE ingredients NOT IN ('garlic', 'wheat') AND budget <= 500 AND season = 'autumn'. The emotion engine analyzes the emotion data and determines the user's emotional state (e.g., "high stress").

[0411] The server then converts the extracted recipe data into JSON format and sends it to the device. The device parses the received JSON data and displays the recipe information on the user interface. The user can view a list of suggested recipes, including recipes such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto." Information related to the user's emotional state is also displayed.

[0412] The user tries the presented recipe and enters their rating in the application, for example, by entering a star rating (e.g., 4 stars) or a detailed comment (e.g., "It was delicious, but a little salty"). The device converts the user-entered rating data into JSON format and sends it to the server.

[0413] The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. The generative AI model is adjusted based on this rating data and reflected in the next recipe generation. The emotion engine also uses user rating data to improve the accuracy of emotional state analysis.

[0414] Here are some examples of prompts:

[0415] 1. "Please suggest recipes that use specific ingredients (e.g., pumpkin, spinach). Also, please take into consideration allergy information (e.g., wheat allergy), budget (e.g., under 500 yen), and seasonal ingredients, and prioritize recipes that have a relaxing effect."

[0416] 2. "The user is feeling stressed. Please suggest some recipes that will help them relax."

[0417] In this way, the present invention is a system that proposes appropriate recipes based on the user's input conditions and emotional state, and repeats the process of improving the system based on evaluations.

[0418] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0419] Step 1:

[0420] The user launches the application and inputs criteria such as ingredients, allergy information, budget, and seasonal ingredients. For example, they can input information such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn." The user also uses a camera or microphone to input their emotional state. The input data is then imported into the application as text, images, and audio data.

[0421] Step 2:

[0422] The device converts the condition data and emotion data entered by the user into JSON format. The converted data (input: user's condition data and emotion data, output: JSON format data) is then sent to the server using the HTTPS protocol. This ensures that the data is encrypted before transmission, ensuring security.

[0423] Step 3:

[0424] The server parses the received JSON data. First, the data parser breaks the JSON data into individual elements and extracts the conditions entered by the user (input: JSON data, output: parsed condition data). Next, the database query generation module generates an SQL query based on the condition data (e.g., "SELECT FROM recipe WHERE ingredients NOT IN ('garlic', 'wheat') AND budget <= 500 AND season = 'Autumn'"). Finally, the emotion engine parses the emotion data and determines the user's emotional state.

[0425] Step 4:

[0426] The emotion engine interprets the user's emotional state based on the provided emotion data and reflects the result (e.g., "high stress") in the extracted recipes. Specifically, the emotion engine adjusts the generative AI model to prioritize recipes containing ingredients that are good for stress (input: analyzed emotion data, output: adjusted recipe query).

[0427] Step 5:

[0428] The server converts the recipe data extracted from the database into JSON format and sends it to the device (input: extracted recipe data, output: recipe data converted into JSON format). By doing this, the server makes it easier for the device to analyze the data it receives.

[0429] Step 6:

[0430] The device analyzes the received JSON data and displays the recipe information on the user interface. Specifically, the device breaks down the JSON data into recipe names, ingredients, cooking procedures, etc., and provides them to the user in a visually easy-to-understand format (input: recipe data in JSON format, output: recipe information displayed on the interface).

[0431] Step 7:

[0432] The user tries the presented recipe and inputs their rating into the application, for example, by giving a star rating (e.g., four stars) or a comment (e.g., "It was delicious, but a little salty") (Input: Thoughts and rating on the recipe, Output: Rating data).

[0433] Step 8:

[0434] The device converts the evaluation data received from the user into JSON format and sends it to the server (input: evaluation data, output: JSON-formatted evaluation data). The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. The generative AI model is also adjusted based on this evaluation data, and this is reflected the next time a recipe is generated (input: JSON-formatted evaluation data, output: updated generative AI model).

[0435] (Application example 2)

[0436] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0437] Conventional recipe suggestion systems only suggest recipes based on the user's input of ingredients, but do not consider the user's emotional state, failing to address the emotional needs of users. Furthermore, they lack an interface for inputting ingredients and emotional state in a physical store. As a result, users lack a way to obtain optimal recipes in stressful situations, reducing the overall convenience and satisfaction of the system.

[0438] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0439] In this invention, the server includes means for accepting input conditions for specific ingredients from a user, means for transmitting the accepted conditions to the server, means for extracting recipes from a database based on the conditions, means for presenting the extracted recipes to the user, means for accepting a user rating, means for transmitting the accepted rating to the server and updating the generative AI model, means for recognizing the user's emotional state, and means for adjusting the recipe based on the emotional state, thereby enabling the server to propose recipes optimized for the user's emotional state and ingredient conditions.

[0440] "User" refers to any individual or entity that uses the System.

[0441] "Specific ingredients" refers to one or more ingredients designated by the user.

[0442] "Input conditions" are conditions that the user specifies to the system, and include specific ingredients, allergy information, budget, seasonal ingredients, and the like.

[0443] "Server" refers to a computer system that processes data received from users and generates recipes in conjunction with a database.

[0444] "Database" refers to a collection of information that stores recipe information.

[0445] "Emotion engine" refers to a software module for recognizing and analyzing a user's emotional state.

[0446] A "recipe" refers to information that includes steps and ingredients needed to prepare a dish.

[0447] "Generative AI model" refers to a recipe model that is generated based on data obtained from the user.

[0448] "Facial recognition technology" refers to technology that uses a camera to identify a user's face and analyze their emotional state.

[0449] The "in-store mode" is a mode intended for use in a physical store, and includes a function that shows where to obtain the selected ingredients.

[0450] "Rating" refers to the feedback a user gives to a suggested recipe.

[0451] "JSON format" stands for JavaScript Object Notation, a lightweight data exchange format.

[0452] The present invention is a system that suggests recipes based on input conditions and emotional state of a user regarding specific ingredients, and is configured as follows.

[0453] 1. User Operation

[0454] Using a smartphone application, users input criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. Using facial recognition technology, users can also input their emotional state at the same time. For example, a user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0455] 2. Data transmission

[0456] The user's device converts the received condition data and emotion data into JSON format and sends it to the server using the HTTPS protocol, thereby maintaining data security.

[0457] 3. Recipe Generation

[0458] The server parses the received JSON data and generates a database query based on the conditions entered by the user. The emotion engine also analyzes the provided emotion data to understand the user's current emotional state. For example, if the user is feeling stressed, the generative AI model is adjusted to suggest recipes appropriate for that emotional state (such as recipes using ingredients with a relaxing effect). The SQL query is generated as follows:

[0459] Exclude certain ingredients (e.g. garlic, wheat)

[0460] Within your budget (e.g., under 500 yen)

[0461] Prioritize seasonal ingredients (e.g. pumpkin)

[0462] Consider ingredients that correspond to your emotional state (e.g., ingredients that have a relaxing effect)

[0463] 4. Presenting the recipe

[0464] The server converts the extracted recipe data into JSON format and sends it to the user's device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto" is displayed. In addition, information related to the user's emotional state is also presented.

[0465] 5. Recipe Rating

[0466] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[0467] 6. Sending and Reflecting Evaluation Data

[0468] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected the next time a recipe is generated. The emotion engine also uses the user's evaluation data to improve the accuracy of its emotional state analysis.

[0469] Hardware and software used

[0470] Hardware: Smartphone (with built-in camera)

[0471] Software: Smartphone application, OpenCV, EmotionRecognizer, server (including database), HTTPS protocol, generative AI model, emotion engine

[0472] Specific examples of possible uses include:

[0473] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0474] 2. The user uses a facial recognition camera to input their current emotional state (e.g., feeling stressed).

[0475] 3. The device sends the condition data and emotion data to the server.

[0476] 4. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, and prioritizes recipes with a relaxing effect based on the analysis results of the emotion engine.

[0477] 5. The extracted recipe is sent to the terminal and displayed to the user.

[0478] 6. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[0479] 7. The device sends the evaluation data to the server.

[0480] 8. The server adds the rating to the database and updates the generative AI model and emotion engine.

[0481] Example prompt sentence:

[0482] Please suggest a recipe that meets the following criteria:

[0483] Ingredients: Pumpkin, spinach

[0484] Allergies: Wheat allergy

[0485] Budget: 500 yen

[0486] Emotional state: Stressed

[0487] Season: Autumn seasonal ingredients

[0488] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0489] Step 1:

[0490] The user starts the smartphone application and selects "physical store mode." Next, they input the ingredients they want to purchase (e.g., pumpkin and spinach). The input ingredient data is temporarily saved in the application.

[0491] Step 2:

[0492] The user inputs their emotional state using facial recognition technology. By activating the camera and capturing their face, the EmotionRecognizer module analyzes their emotions. The analyzed emotional data (e.g., feeling stressed) is generated. This emotional data is temporarily stored along with the food ingredient data.

[0493] Step 3:

[0494] The terminal compiles the information entered by the user, such as ingredient information, emotional data, allergy information, budget, and seasonal ingredients, and converts it into JSON format. The converted data is sent to the server using the HTTPS protocol. The input is the user data, and the output is the JSON data sent to the server.

[0495] Step 4:

[0496] The server parses the received JSON data. It generates a database query based on the input criteria and extracts matching recipes from the recipe database. Specifically, the following filtering is applied: exclude specific ingredients, stay within budget, prioritize seasonal ingredients, and consider ingredients according to emotional state. The input is JSON data, and the output is the filtered recipe data.

[0497] Step 5:

[0498] The server's emotion engine adjusts the generative AI model based on the analyzed emotion data to prioritize recipes that suit the user's emotional state. The generative AI model is configured to recommend recipes that use ingredients with a relaxing effect, for example. The input is emotion data, and the output is adjusted recipe data.

[0499] Step 6:

[0500] The server converts the extracted and adjusted recipe data into JSON format and sends it to the terminal. The terminal parses the received JSON data and displays the recipe information on the user interface. Specifically, it displays recipes such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto." The input is the recipe data, and the output is the displayed recipe information.

[0501] Step 7:

[0502] Users try the displayed recipes and enter a rating (e.g., four stars) and comments in the application. This rating data is temporarily stored on the device.

[0503] Step 8:

[0504] The device converts the evaluation data entered by the user into JSON format and sends it to the server using the HTTPS protocol. The server analyzes the received evaluation data and adds it to a database as evaluation information for the corresponding recipe. Furthermore, the generative AI model is adjusted using this evaluation data and reflected the next time a recipe is generated. The input is the evaluation data, and the output is the adjusted generative AI model.

[0505] Example prompt sentence:

[0506] Please suggest a recipe that meets the following criteria:

[0507] Ingredients: Pumpkin, spinach

[0508] Allergies: Wheat allergy

[0509] Budget: 500 yen

[0510] Emotional state: Stressed

[0511] Season: Autumn seasonal ingredients

[0512] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0513] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0514] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0515] [Second embodiment]

[0516] FIG. 3 shows an example of the configuration of a data processing system 210 according to the second embodiment.

[0517] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0518] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0519] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, and the camera 42 are also connected to the bus 52.

[0520] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[0521] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[0522] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0523] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0524] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0525] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0526] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0527] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal."

[0528] The system of the present invention has a user, a terminal, and a server as its main components, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients, and updating the generative AI model based on the user's evaluation.

[0529] System Overview

[0530] User operations

[0531] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, a user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "I want pumpkin as a seasonal ingredient in autumn."

[0532] Sending conditions

[0533] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, which ensures data security.

[0534] Recipe Generation

[0535] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[0536] The server generates an SQL query as follows to extract the corresponding recipes from the database:

[0537] Exclude certain ingredients (e.g. garlic, wheat)

[0538] Within your budget (e.g., under 500 yen)

[0539] Prioritize seasonal ingredients (e.g. pumpkin)

[0540] Recipe presentation

[0541] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto" is displayed.

[0542] Recipe Rating

[0543] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[0544] Submitting and reviewing your evaluation

[0545] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[0546] Specific examples

[0547] For example:

[0548] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0549] 2. The device sends these conditions to the server.

[0550] 3. The server extracts recipes such as "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto" based on the conditions and sends them to the terminal.

[0551] 4. The device displays the received recipe to the user.

[0552] 5. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[0553] 6. The device sends the evaluation data to the server.

[0554] 7. The server adds the rating to the database and updates the generative AI model.

[0555] In this way, the present invention is a system that continues to suggest appropriate recipes based on the user's input conditions and evaluations.

[0556] The processing flow will be explained below.

[0557] Step 1:

[0558] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[0559] Step 2:

[0560] The terminal converts the condition data entered by the user into JSON format. For example, the data is converted as follows:

[0561] json

[0562] {

[0563] "preferences": {

[0564] "garlic": "no",

[0565] "allergies": ["wheat"],

[0566] "budget": 500,

[0567] "season_ingredient": "pumpkin"

[0568] }

[0569] }

[0570] Step 3:

[0571] The terminal sends the converted JSON data to the server using the HTTPS protocol, which ensures that the data arrives securely at the server.

[0572] Step 4:

[0573] The server parses the received JSON data, which is then broken down into fields based on the user's input (e.g., garlic, allergies, budget, season_ingredient).

[0574] Step 5:

[0575] The server generates a database query based on the parsed data to exclude certain ingredients. For example, the following SQL query is generated:

[0576] sql

[0577] SELECT FROM recipes

[0578] WHERE NOT (ingredients LIKE '%garlic%')

[0579] AND NOT (ingredients LIKE '%wheat%')

[0580] AND total_cost <= 500

[0581] AND ingredients LIKE '%pumpkin%'

[0582] ORDER BY total_rating DESC;

[0583] Step 6:

[0584] The server executes the generated query and extracts recipes from the database that match the criteria, such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto."

[0585] Step 7:

[0586] The server converts the extracted recipe data into JSON format, for example, the following JSON data is generated:

[0587] json

[0588] {

[0589] "recipes": [

[0590] {

[0591] "title": "Pumpkin and spinach gratin",

[0592] "ingredients": ["pumpkin", "spinach", ...],

[0593] "total_cost": 450,

[0594] "rating": 4.5

[0595] },

[0596] {

[0597] "title": "Pumpkin and mushroom risotto",

[0598] "ingredients": ["pumpkin", "mushroom", ...],

[0599] "total_cost": 480,

[0600] "rating": 4.7

[0601] }

[0602] ]

[0603] }

[0604] Step 8:

[0605] The server sends the converted JSON data to the terminal.

[0606] Step 9:

[0607] The device parses the received JSON data and displays it on the user interface, such as recipe information like "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto."

[0608] Step 10:

[0609] The user selects a dish from the presented recipes and actually cooks it. After cooking, the user rates the recipe in the application (e.g., 4 out of 5 stars) and adds detailed comments.

[0610] Step 11:

[0611] The terminal converts the rating data entered by the user into JSON format. For example, the data is converted as follows:

[0612] json

[0613] {

[0614] "recipe_id": 12345,

[0615] "rating": 4,

[0616] "comment": "The pumpkin flavor was strong and delicious"

[0617] }

[0618] Step 12:

[0619] The terminal transmits the converted rating data to the server using the HTTPS protocol.

[0620] Step 13:

[0621] The server analyzes the received evaluation data and adds the evaluation information of the corresponding recipe to the database.

[0622] Step 14:

[0623] The server updates the generative AI model based on the newly received evaluation data, which enables it to propose recipes that better match the user's preferences the next time recipes are generated.

[0624] Example 1

[0625] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0626] Conventional recipe suggestion systems have difficulty responding flexibly to specific user conditions and requests, and are particularly inadequate at generating recipes that take into account food allergies, budgets, and seasonal ingredients. Furthermore, they lack a mechanism for incorporating user feedback, making it difficult to regularly provide suggestions that satisfy users.

[0627] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0628] In this invention, the server includes means for accepting input conditions for specific ingredients from a user, means for transmitting the accepted conditions to a digital device, means for extracting information from a data store based on the conditions, means for presenting the extracted information to the user, means for accepting user ratings, means for transmitting the accepted ratings to the digital device and updating the generative artificial intelligence model, and means for transmitting the extracted information using a secure communication protocol. This enables more accurate recipe suggestions that correspond to the user's conditions and allows for continuous improvement that reflects the user's ratings.

[0629] "User" refers to a person who uses the system of the present invention to input specific ingredients and conditions.

[0630] "Input conditions" refer to requirements specified by the user regarding specific ingredients, allergy information, budget, seasonal ingredients, etc.

[0631] "Digital device" refers to an electronic device that receives user input, transmits it to a server, and displays the results. Examples of such devices include smartphones and tablet devices.

[0632] "Server" refers to a central control device that queries a database based on criteria received from a user and extracts, generates, and transmits relevant information.

[0633] "Information" refers to recipes and other related data extracted from a database based on user-specified criteria.

[0634] "Data store" refers to a database or storage system for storing and managing information.

[0635] "Secure communications protocol" refers to a communications method used to preserve data confidentiality and integrity, such as HTTPS.

[0636] A "generative artificial intelligence model" refers to a machine learning model that learns from user evaluation data and reflects that knowledge in its next proposal.

[0637] "Evaluation" is feedback that a user gives to a presented recipe, and includes star ratings, comments, and the like.

[0638] The present invention is a system whose main components are the user, terminal, and server. It proposes, extracts, and displays recipes based on conditions specified by the user, such as ingredients, allergy information, budget, and seasonal ingredients, and updates the generative AI model based on the user's evaluation.

[0639] System configuration

[0640] User operations

[0641] The user launches the application and inputs specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, the user inputs conditions such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[0642] Sending condition data

[0643] The terminal converts the condition data entered by the user into JSON format and transmits it securely to the server using the HTTPS protocol, thereby ensuring the confidentiality and integrity of the data.

[0644] Recipe Generation

[0645] The server parses the received JSON data and generates a database query based on the user's input criteria. Specifically, the server creates an SQL query to extract recipes that exclude specific ingredients (e.g., garlic, wheat) and prioritize seasonal ingredients (e.g., pumpkin) within budget (e.g., under 500 yen). An example of an SQL query is shown below:

[0646] sql

[0647] SELECT FROM recipes

[0648] WHERE NOT ingredients LIKE '%garlic%'

[0649] AND NOT ingredients LIKE '%wheat%'

[0650] AND price <= 500

[0651] AND ingredients LIKE '%pumpkin%'

[0652] Recipe presentation

[0653] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays the specific recipe name, required ingredients, and cooking steps on the user interface. For example, the user might be offered recipes such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto."

[0654] Recipe Rating

[0655] Users can try the recipes presented to them and then rate them in the application. Users can also provide star ratings (e.g., 4 out of 5 stars) and feedback comments.

[0656] Sending and reflecting evaluation data

[0657] The device converts the user-entered rating data into JSON format and sends it to the server using a secure communication protocol (e.g., HTTPS). The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. At the same time, the generative AI model learns from this rating data and reflects it in the next recipe suggestions.

[0658] Specific examples

[0659] For example:

[0660] 1. The user launches the application and enters the following criteria: "I don't like garlic," "I'm allergic to wheat," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0661] 2. The device converts these conditions into JSON format and sends it to the server using the HTTPS protocol.

[0662] 3. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, converts them into JSON format, and sends them to the terminal.

[0663] 4. The device analyzes the received recipe and displays it on the user interface.

[0664] 5. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[0665] 6. The device converts the evaluation data into JSON format and sends it to the server using the HTTPS protocol.

[0666] 7. The server analyzes the received evaluation data, adds the evaluation information for the corresponding recipe to the database, and updates the generative AI model.

[0667] Example prompts for generative AI models

[0668] The user has entered "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "I want pumpkin, which is a seasonal ingredient in autumn." Please suggest a recipe based on that.

[0669] In this way, the present invention is a recipe suggestion system that suggests recipes that meet the user's requirements and is capable of continuous improvement that reflects the user's evaluations.

[0670] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0671] Step 1: User input

[0672] The user launches the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, the user might specify criteria such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn." The input data is entered into the application's form.

[0673] Input: Specific ingredients, allergy information, budget, seasonal ingredients

[0674] Output: User input data

[0675] Step 2: Sending condition data

[0676] The terminal converts the condition data entered by the user into JSON format, after which the terminal transmits the data securely to the server using the HTTPS protocol, which ensures the confidentiality and integrity of the data.

[0677] Input: User-entered data

[0678] Data processing: Convert input data into JSON format

[0679] Output: Condition data in JSON format

[0680] Step 3: Generate the recipe

[0681] The server analyzes the received JSON data and generates a database query based on the user's criteria. For example, the server creates an SQL query to search for recipes that do not contain "garlic" or "wheat," that are within a budget of 500 yen, and that use "pumpkin" as a seasonal ingredient. The server executes this SQL query to extract matching recipes from the database.

[0682] Input: Condition data in JSON format

[0683] Data processing / calculation: SQL query generation and execution

[0684] Output: Recipe data

[0685] Step 4: Present the recipe

[0686] The server converts the extracted recipe data into JSON format and sends it to the device, which then analyzes the received recipe data and displays the specific recipe name, required ingredients, and cooking steps on the user interface.

[0687] Input: Recipe data

[0688] Data processing: Convert to JSON format

[0689] Output: Recipe data in JSON format

[0690] Step 5: Evaluate the recipe

[0691] The user tries the displayed recipe and enters their rating in the application. The user can write a star rating (e.g., 4 out of 5 stars) and feedback comments. This rating data is used for subsequent processing.

[0692] Input: User's recipe rating

[0693] Output: Evaluation data

[0694] Step 6: Submit and reflect evaluation data

[0695] The device converts the user-entered rating data into JSON format and sends it to the server using a secure communication protocol (e.g., HTTPS). The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. Furthermore, the generative AI model learns from this rating data and reflects it in the next recipe suggestions.

[0696] Input: Evaluation data

[0697] Data processing: Convert to JSON format and analyze

[0698] Output: Updated recipe rating information and generative AI model

[0699] In this way, the system can tailor recipe suggestions to the user's requirements and continuously improve based on user feedback.

[0700] (Application example 1)

[0701] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0702] Conventional recipe suggestion systems only provide recipes based on the user's ingredient requirements, and lack a mechanism for using user ratings to improve the system's suggestion accuracy. Furthermore, when suggesting ingredients or recipes, links to where users can purchase the ingredients are often not provided, making it difficult to take immediate action. Furthermore, even when suggesting recipes that take seasonal ingredients or budget into consideration, such information cannot be systematically incorporated. This has prevented the system from improving user convenience and satisfaction.

[0703] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0704] In this invention, the server includes a means for accepting input conditions for specific ingredients from a user, a means for transmitting the accepted conditions to the server, a means for extracting recipes from a database based on the conditions, a means for presenting the extracted recipes to the user and displaying links where the corresponding ingredients and recipes can be purchased together, a means for accepting user ratings, and a means for transmitting the accepted ratings to the server and updating the generative AI model. This allows users to obtain recipes that meet their ingredient requirements and immediately purchase related ingredients. Furthermore, by improving the system based on user ratings, users can receive more accurate suggestions.

[0705] A "user" is a consumer who utilizes the system and provides input requirements regarding a particular food ingredient.

[0706] "Input conditions" refers to information such as specific ingredients, allergy information, budget, and seasonal ingredients that the user provides to the system.

[0707] The "server" is a central computer system that processes data based on the conditions received from the user, proposes recipes, and evaluates them.

[0708] "Means for extracting recipes from a database based on conditions" refers to the function of the server searching and extracting recipes from a database that meet the conditions provided by the user.

[0709] "Means for presenting extracted recipes to the user" refers to a function for the server to provide the extracted recipes to the user in an easy-to-view format.

[0710] "Means for displaying a link where the relevant ingredients and recipe can be purchased together" refers to a function that displays a link where the user can simultaneously purchase the recipe provided by the system and the ingredients related to it.

[0711] The "means for accepting user ratings" refers to a function that allows a user to input a rating for a recipe that they have tried.

[0712] "Means for updating the generative AI model" refers to the function of adjusting the AI ​​model based on user evaluation data and reflecting this in the next recipe suggestion.

[0713] The "JSON format" is a lightweight data exchange format for exchanging user input conditions and data between applications.

[0714] The system for implementing this invention consists primarily of a user, a terminal, and a server. The user specifies input conditions using the terminal, and the server generates and presents recipes based on those conditions. The system also improves by updating the generative AI model based on user evaluations.

[0715] Program processing explanation

[0716] 1. User operations

[0717] Users open the application and input criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal for under 500 yen," and "I want pumpkin as a seasonal ingredient in autumn." This input is based on the user's preferences and specific constraints.

[0718] 2. Submitting the conditions

[0719] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, ensuring secure data transmission.

[0720] 3. Recipe Generation

[0721] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[0722] 4. Presenting the recipe

[0723] The server extracts the relevant recipes from the database, converts the data into JSON format, and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto" is displayed, along with links to purchase the corresponding ingredients and recipes.

[0724] 5. Recipe Rating

[0725] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[0726] 6. Submitting and Reflecting Ratings

[0727] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[0728] Hardware / Software used

[0729] Device: Smartphone

[0730] Software: Commercially available browsers and dedicated applications

[0731] Server: Python, Flask (server side), SQL database

[0732] Examples of concrete examples and prompts

[0733] Examples:

[0734] The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal autumn ingredient." The device sends these criteria to the server. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the criteria and sends them to the device. The device displays the received recipes to the user, along with links to purchase related ingredients. The user makes "Pumpkin and spinach gratin" and rates it four stars. The device sends the rating data to the server, which adds the rating to a database and updates the generative AI model.

[0735] Example prompt sentence:

[0736] "Please suggest recipes based on specific ingredient conditions entered by the user. The conditions are: I don't like garlic, I have a wheat allergy, the cost is under 500 yen per meal, and pumpkin is a seasonal ingredient in autumn."

[0737] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0738] Step 1:

[0739] Users launch the smartphone application and input criteria such as specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, users might input criteria such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn."

[0740] (Input) Condition data entered by the user

[0741] (Output) Prepare smartphone device for data transmission

[0742] Step 2:

[0743] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, ensuring data security during this process.

[0744] (Input) Condition data entered by the user (text format)

[0745] (Output) JSON format data sent to the server

[0746] Step 3:

[0747] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[0748] (Input) Condition data in JSON format received by the server

[0749] (Output) Generated SQL query

[0750] Step 4:

[0751] The server uses the generated SQL query to extract the corresponding recipes from the database. The extracted recipe information includes details such as the recipe name, ingredients, and cooking instructions.

[0752] (Input) Generated SQL query

[0753] (Output) Recipe information extracted from the database

[0754] Step 5:

[0755] The server converts the extracted recipe into JSON format and sends it to the terminal using the HTTPS protocol.

[0756] (Input) Recipe information extracted from the database

[0757] (Output) JSON format recipe data sent to the device

[0758] Step 6:

[0759] The device parses the JSON-formatted recipe data received from the server and displays it in a user interface, including the recipe name, ingredient list, detailed instructions, and links to purchase the associated ingredients and recipe.

[0760] (Input) JSON format recipe data received from the server

[0761] (Output) Recipe information and purchase link displayed in the user interface

[0762] Step 7:

[0763] Users try the displayed recipes and provide a rating within the application, including a star rating (e.g., 4 out of 5 stars) and detailed comments.

[0764] (Input) User rating data (star ratings and comments)

[0765] (Output) Prepare smartphone device for data transmission

[0766] Step 8:

[0767] The terminal converts the evaluation data entered by the user into JSON format and sends it to the server again using the HTTPS protocol.

[0768] (Input) User evaluation data (text format)

[0769] (Output) JSON formatted rating data sent to the server

[0770] Step 9:

[0771] The server analyzes the received evaluation data and adds the corresponding recipe evaluation information to the database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[0772] (Input) JSON formatted rating data received by the server

[0773] (Output) Evaluation information and updated generative AI model added to the database

[0774] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0775] The system of the present invention has as its main components the user, a terminal, a server, and an emotion engine, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients and their emotional state, and updating the generative AI model based on the user's evaluation of these recipes.

[0776] System Overview

[0777] User operations

[0778] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, the user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn." At the same time, data (images, voice, text, etc.) can be input at the same time for the emotion engine to analyze the user's emotions.

[0779] Sending Conditions and Emotion Data

[0780] The device converts the condition data and emotion data entered by the user into JSON format and sends it to the server using the HTTPS protocol, thereby ensuring data security.

[0781] Recipe Generation

[0782] The server analyzes the received JSON data and generates a database query based on the conditions entered by the user. The emotion engine also analyzes the provided emotion data to understand the user's current emotional state. For example, if the user is feeling stressed, the generative AI model is adjusted to suggest recipes appropriate for that emotional state (such as recipes using ingredients with a relaxing effect). Specifically, the SQL query is generated as follows:

[0783] Exclude certain ingredients (e.g. garlic, wheat)

[0784] Within your budget (e.g., under 500 yen)

[0785] Prioritize seasonal ingredients (e.g. pumpkin)

[0786] Consider ingredients that correspond to your emotional state (e.g., ingredients that have a relaxing effect)

[0787] Recipe presentation

[0788] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto" is displayed. In addition, information related to the user's emotional state is also presented.

[0789] Recipe Rating

[0790] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[0791] Submitting and reviewing your evaluation

[0792] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected the next time a recipe is generated. The emotion engine also uses the user's evaluation data to improve the accuracy of its emotional state analysis.

[0793] Specific examples

[0794] For example:

[0795] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0796] 2. The user uses a facial recognition camera to input their current emotional state (e.g., feeling stressed).

[0797] 3. The device sends the condition data and emotion data to the server.

[0798] 4. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, and prioritizes recipes with a relaxing effect based on the analysis results of the emotion engine.

[0799] 5. The extracted recipe is sent to the terminal and displayed to the user.

[0800] 6. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[0801] 7. The device sends the evaluation data to the server.

[0802] 8. The server adds the rating to the database and updates the generative AI model and emotion engine.

[0803] In this way, the present invention is a system that suggests appropriate recipes according to the user's input conditions and emotional state.

[0804] The processing flow will be explained below.

[0805] Step 1:

[0806] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[0807] Step 2:

[0808] Users input their current emotional state using an emotion-detecting camera and microphone. The emotion-detecting camera analyzes the user's facial expressions, and the microphone analyzes the user's vocal tone.

[0809] Step 3:

[0810] The device converts the condition data and emotion data entered by the user into JSON format. An example of the converted data is as follows:

[0811] json

[0812] {

[0813] "preferences": {

[0814] "garlic": "no",

[0815] "allergies": ["wheat"],

[0816] "budget": 500,

[0817] "season_ingredient": "pumpkin"

[0818] },

[0819] "emotion": {

[0820] "stress_level": "high",

[0821] "mood": "anxious"

[0822] }

[0823] }

[0824] Step 4:

[0825] The terminal sends the converted JSON data to the server using the HTTPS protocol, which ensures that the data arrives securely at the server.

[0826] Step 5:

[0827] The server parses the received JSON data, which is then broken down into fields based on the user's input (e.g., garlic, allergies, budget, season_ingredient) and emotional states (e.g., stress_level, mood).

[0828] Step 6:

[0829] The server generates a database query based on the parsed data to exclude certain ingredients. For example, the following SQL query is generated:

[0830] sql

[0831] SELECT FROM recipes

[0832] WHERE NOT (ingredients LIKE '%garlic%')

[0833] AND NOT (ingredients LIKE '%wheat%')

[0834] AND total_cost <= 500

[0835] AND ingredients LIKE '%pumpkin%'

[0836] ORDER BY total_rating DESC;

[0837] Step 7:

[0838] The server uses an emotion engine to evaluate the user's emotional state and prioritizes ingredients and recipes that have a relaxing effect. The emotion engine prioritizes recipes that contain ingredients that reduce stress (e.g., chamomile, lavender).

[0839] Step 8:

[0840] The server executes the generated query and extracts recipes from the database that match the criteria, such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto."

[0841] Step 9:

[0842] The server converts the extracted recipe data into JSON format, for example, the following JSON data is generated:

[0843] json

[0844] {

[0845] "recipes": [

[0846] {

[0847] "title": "Pumpkin and spinach gratin",

[0848] "ingredients": ["pumpkin", "spinach", ...],

[0849] "total_cost": 450,

[0850] "rating": 4.5,

[0851] "emotion_suitability": "high"

[0852] },

[0853] {

[0854] "title": "Pumpkin and mushroom risotto",

[0855] "ingredients": ["pumpkin", "mushroom", ...],

[0856] "total_cost": 480,

[0857] "rating": 4.7,

[0858] "emotion_suitability": "medium"

[0859] }

[0860] ]

[0861] }

[0862] Step 10:

[0863] The server sends the converted JSON data to the terminal.

[0864] Step 11:

[0865] The device parses the received JSON data and displays it in the user interface. For example, it displays recipe information such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto," as well as information related to the user's emotional state (e.g., "highly relaxing").

[0866] Step 12:

[0867] The user selects a dish from the presented recipes and actually cooks it. After cooking, the user rates the recipe in the application (e.g., 4 out of 5 stars) and enters detailed comments.

[0868] Step 13:

[0869] The device converts the rating data entered by the user into JSON format and sends it to the server. For example, the data is converted as follows:

[0870] json

[0871] {

[0872] "recipe_id": 12345,

[0873] "rating": 4,

[0874] "comment": "The pumpkin flavor was strong and delicious",

[0875] "emotion_feedback": {

[0876] "relaxation_effect": "high",

[0877] "mood_improvement": "significant"

[0878] }

[0879] }

[0880] Step 14:

[0881] The server analyzes the received evaluation data and adds the evaluation information of the corresponding recipe to the database.

[0882] Step 15:

[0883] The server updates the generative AI model and emotion engine based on the newly received evaluation data, allowing it to propose recipes that better match the user's emotional state and preferences the next time recipes are generated.

[0884] Example 2

[0885] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0886] In today's lifestyles, users often find it difficult to find suitable recipes that take into account ingredients, allergies, budgets, and seasonal ingredients. Taking the user's emotional state into account would also enable more satisfying recipe suggestions, but this has been difficult to achieve with conventional systems. Furthermore, the lack of a feedback function that reflects the user's evaluation of the recipe and improves the next suggestions means that user satisfaction does not improve over the long term.

[0887] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0888] In this invention, the server includes means for accepting user input conditions, means for transmitting the conditions to the server, means for generating a database query, means including an emotion engine for adjusting recipes based on the user's emotional state, means for extracting recipes from the database based on the conditions and the emotional state, means for presenting recipes to the user, means for accepting user ratings, and means for transmitting the ratings to the server and updating the generative AI model. This makes it possible to propose appropriate recipes based on the user's input conditions and emotional state, and realizes system improvements based on ratings.

[0889] A "user" is a person who uses this system to input ingredients and conditions, and makes recipe suggestions and evaluations.

[0890] "Input conditions" is information that allows the user to specify specific ingredients, allergy information, budget, seasonal ingredients, and the like.

[0891] The "server" is a central processing unit that processes the received information, generates database queries, extracts recipes, runs the emotion engine, and collects and processes rating data.

[0892] A "database query" is a query statement that the server generates to extract recipes that meet the user's requirements from the database.

[0893] The "Emotion Engine" is a system that analyzes the user's emotional state and suggests recipes that are appropriate for that state.

[0894] A "recipe" is a cooking instruction manual that includes information such as ingredients, steps, and cooking time.

[0895] "Evaluation" refers to the act of a user providing feedback on a presented recipe in the form of a star rating, a comment, or the like.

[0896] A "generative AI model" is an artificial intelligence model that suggests and adjusts recipes based on the data it receives.

[0897] The system of this invention has as its main components the user, a terminal, a server, and an emotion engine, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients and their emotional state, and for updating the generative AI model based on the user's evaluation of these recipes.

[0898] First, the user opens the application and inputs criteria such as a specific food ingredient (e.g., pumpkin), allergy information (e.g., garlic dislike, wheat allergy), budget (e.g., under 500 yen), and seasonal ingredients (e.g., pumpkin in autumn). The user also uses an input device such as a camera or microphone to input their current emotional state (e.g., feeling stressed). This information is captured by the application as text input, image, or voice data.

[0899] Next, the device converts the condition data and emotion data entered by the user into JSON format. This process is performed by the data conversion module. The converted data is sent to the server using the HTTPS protocol. Using the HTTPS protocol encrypts the data and maintains security.

[0900] The server analyzes the received JSON data and generates a database query based on the conditions entered by the user. The server's internal SQL query generation module generates an appropriate query based on the request. The emotion engine also analyzes the provided emotion data (e.g., image recognition, voice recognition) to understand the user's current emotional state. Based on this information, the generative AI model filters recipes that match the user's emotions.

[0901] For example, the following SQL query is generated: SELECT FROM recipe WHERE ingredients NOT IN ('garlic', 'wheat') AND budget <= 500 AND season = 'autumn'. The emotion engine analyzes the emotion data and determines the user's emotional state (e.g., "high stress").

[0902] The server then converts the extracted recipe data into JSON format and sends it to the device. The device parses the received JSON data and displays the recipe information on the user interface. The user can view a list of suggested recipes, including recipes such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto." Information related to the user's emotional state is also displayed.

[0903] The user tries the presented recipe and enters their rating in the application, for example, by entering a star rating (e.g., 4 stars) or a detailed comment (e.g., "It was delicious, but a little salty"). The device converts the user-entered rating data into JSON format and sends it to the server.

[0904] The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. The generative AI model is adjusted based on this rating data and reflected in the next recipe generation. The emotion engine also uses user rating data to improve the accuracy of emotional state analysis.

[0905] Here are some examples of prompts:

[0906] 1. "Please suggest recipes that use specific ingredients (e.g., pumpkin, spinach). Also, please take into consideration allergy information (e.g., wheat allergy), budget (e.g., under 500 yen), and seasonal ingredients, and prioritize recipes that have a relaxing effect."

[0907] 2. "The user is feeling stressed. Please suggest some recipes that will help them relax."

[0908] In this way, the present invention is a system that proposes appropriate recipes based on the user's input conditions and emotional state, and repeats the process of improving the system based on evaluations.

[0909] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0910] Step 1:

[0911] The user launches the application and inputs criteria such as ingredients, allergy information, budget, and seasonal ingredients. For example, they can input information such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn." The user also uses a camera or microphone to input their emotional state. The input data is then imported into the application as text, images, and audio data.

[0912] Step 2:

[0913] The device converts the condition data and emotion data entered by the user into JSON format. The converted data (input: user's condition data and emotion data, output: JSON format data) is then sent to the server using the HTTPS protocol. This ensures that the data is encrypted before transmission, ensuring security.

[0914] Step 3:

[0915] The server parses the received JSON data. First, the data parser breaks the JSON data into individual elements and extracts the conditions entered by the user (input: JSON data, output: parsed condition data). Next, the database query generation module generates an SQL query based on the condition data (e.g., "SELECT FROM recipe WHERE ingredients NOT IN ('garlic', 'wheat') AND budget <= 500 AND season = 'Autumn'"). Finally, the emotion engine parses the emotion data and determines the user's emotional state.

[0916] Step 4:

[0917] The emotion engine interprets the user's emotional state based on the provided emotion data and reflects the result (e.g., "high stress") in the extracted recipes. Specifically, the emotion engine adjusts the generative AI model to prioritize recipes containing ingredients that are good for stress (input: analyzed emotion data, output: adjusted recipe query).

[0918] Step 5:

[0919] The server converts the recipe data extracted from the database into JSON format and sends it to the device (input: extracted recipe data, output: recipe data converted into JSON format). By doing this, the server makes it easier for the device to analyze the data it receives.

[0920] Step 6:

[0921] The device analyzes the received JSON data and displays the recipe information on the user interface. Specifically, the device breaks down the JSON data into recipe names, ingredients, cooking procedures, etc., and provides them to the user in a visually easy-to-understand format (input: recipe data in JSON format, output: recipe information displayed on the interface).

[0922] Step 7:

[0923] The user tries the presented recipe and inputs their rating into the application, for example, by giving a star rating (e.g., four stars) or a comment (e.g., "It was delicious, but a little salty") (Input: Thoughts and rating on the recipe, Output: Rating data).

[0924] Step 8:

[0925] The device converts the evaluation data received from the user into JSON format and sends it to the server (input: evaluation data, output: JSON-formatted evaluation data). The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. The generative AI model is also adjusted based on this evaluation data, and this is reflected the next time a recipe is generated (input: JSON-formatted evaluation data, output: updated generative AI model).

[0926] (Application example 2)

[0927] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0928] Conventional recipe suggestion systems only suggest recipes based on the user's input of ingredients, but do not consider the user's emotional state, failing to address the emotional needs of users. Furthermore, they lack an interface for inputting ingredients and emotional state in a physical store. As a result, users lack a way to obtain optimal recipes in stressful situations, reducing the overall convenience and satisfaction of the system.

[0929] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0930] In this invention, the server includes means for accepting input conditions for specific ingredients from a user, means for transmitting the accepted conditions to the server, means for extracting recipes from a database based on the conditions, means for presenting the extracted recipes to the user, means for accepting a user rating, means for transmitting the accepted rating to the server and updating the generative AI model, means for recognizing the user's emotional state, and means for adjusting the recipe based on the emotional state, thereby enabling the server to propose recipes optimized for the user's emotional state and ingredient conditions.

[0931] "User" refers to any individual or entity that uses the System.

[0932] "Specific ingredients" refers to one or more ingredients designated by the user.

[0933] "Input conditions" are conditions that the user specifies to the system, and include specific ingredients, allergy information, budget, seasonal ingredients, and the like.

[0934] "Server" refers to a computer system that processes data received from users and generates recipes in conjunction with a database.

[0935] "Database" refers to a collection of information that stores recipe information.

[0936] "Emotion engine" refers to a software module for recognizing and analyzing a user's emotional state.

[0937] A "recipe" refers to information that includes steps and ingredients needed to prepare a dish.

[0938] "Generative AI model" refers to a recipe model that is generated based on data obtained from the user.

[0939] "Facial recognition technology" refers to technology that uses a camera to identify a user's face and analyze their emotional state.

[0940] The "in-store mode" is a mode intended for use in a physical store, and includes a function that shows where to obtain the selected ingredients.

[0941] "Rating" refers to the feedback a user gives to a suggested recipe.

[0942] "JSON format" stands for JavaScript Object Notation, a lightweight data exchange format.

[0943] The present invention is a system that suggests recipes based on input conditions and emotional state of a user regarding specific ingredients, and is configured as follows.

[0944] 1. User Operation

[0945] Using a smartphone application, users input criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. Using facial recognition technology, users can also input their emotional state at the same time. For example, a user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0946] 2. Data transmission

[0947] The user's device converts the received condition data and emotion data into JSON format and sends it to the server using the HTTPS protocol, thereby maintaining data security.

[0948] 3. Recipe Generation

[0949] The server parses the received JSON data and generates a database query based on the conditions entered by the user. The emotion engine also analyzes the provided emotion data to understand the user's current emotional state. For example, if the user is feeling stressed, the generative AI model is adjusted to suggest recipes appropriate for that emotional state (such as recipes using ingredients with a relaxing effect). The SQL query is generated as follows:

[0950] Exclude certain ingredients (e.g. garlic, wheat)

[0951] Within your budget (e.g., under 500 yen)

[0952] Prioritize seasonal ingredients (e.g. pumpkin)

[0953] Consider ingredients that correspond to your emotional state (e.g., ingredients that have a relaxing effect)

[0954] 4. Presenting the recipe

[0955] The server converts the extracted recipe data into JSON format and sends it to the user's device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto" is displayed. In addition, information related to the user's emotional state is also presented.

[0956] 5. Recipe Rating

[0957] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[0958] 6. Sending and Reflecting Evaluation Data

[0959] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected the next time a recipe is generated. The emotion engine also uses the user's evaluation data to improve the accuracy of its emotional state analysis.

[0960] Hardware and software used

[0961] Hardware: Smartphone (with built-in camera)

[0962] Software: Smartphone application, OpenCV, EmotionRecognizer, server (including database), HTTPS protocol, generative AI model, emotion engine

[0963] Specific examples of possible uses include:

[0964] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[0965] 2. The user uses a facial recognition camera to input their current emotional state (e.g., feeling stressed).

[0966] 3. The device sends the condition data and emotion data to the server.

[0967] 4. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, and prioritizes recipes with a relaxing effect based on the analysis results of the emotion engine.

[0968] 5. The extracted recipe is sent to the terminal and displayed to the user.

[0969] 6. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[0970] 7. The device sends the evaluation data to the server.

[0971] 8. The server adds the rating to the database and updates the generative AI model and emotion engine.

[0972] Example prompt sentence:

[0973] Please suggest a recipe that meets the following criteria:

[0974] Ingredients: Pumpkin, spinach

[0975] Allergies: Wheat allergy

[0976] Budget: 500 yen

[0977] Emotional state: Stressed

[0978] Season: Autumn seasonal ingredients

[0979] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0980] Step 1:

[0981] The user starts the smartphone application and selects "physical store mode." Next, they input the ingredients they want to purchase (e.g., pumpkin and spinach). The input ingredient data is temporarily saved in the application.

[0982] Step 2:

[0983] The user inputs their emotional state using facial recognition technology. By activating the camera and capturing their face, the EmotionRecognizer module analyzes their emotions. The analyzed emotional data (e.g., feeling stressed) is generated. This emotional data is temporarily stored along with the food ingredient data.

[0984] Step 3:

[0985] The terminal compiles the information entered by the user, such as ingredient information, emotional data, allergy information, budget, and seasonal ingredients, and converts it into JSON format. The converted data is sent to the server using the HTTPS protocol. The input is the user data, and the output is the JSON data sent to the server.

[0986] Step 4:

[0987] The server parses the received JSON data. It generates a database query based on the input criteria and extracts matching recipes from the recipe database. Specifically, the following filtering is applied: exclude specific ingredients, stay within budget, prioritize seasonal ingredients, and consider ingredients according to emotional state. The input is JSON data, and the output is the filtered recipe data.

[0988] Step 5:

[0989] The server's emotion engine adjusts the generative AI model based on the analyzed emotion data to prioritize recipes that suit the user's emotional state. The generative AI model is configured to recommend recipes that use ingredients with a relaxing effect, for example. The input is emotion data, and the output is adjusted recipe data.

[0990] Step 6:

[0991] The server converts the extracted and adjusted recipe data into JSON format and sends it to the terminal. The terminal parses the received JSON data and displays the recipe information on the user interface. Specifically, it displays recipes such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto." The input is the recipe data, and the output is the displayed recipe information.

[0992] Step 7:

[0993] Users try the displayed recipes and enter a rating (e.g., four stars) and comments in the application. This rating data is temporarily stored on the device.

[0994] Step 8:

[0995] The device converts the evaluation data entered by the user into JSON format and sends it to the server using the HTTPS protocol. The server analyzes the received evaluation data and adds it to a database as evaluation information for the corresponding recipe. Furthermore, the generative AI model is adjusted using this evaluation data and reflected the next time a recipe is generated. The input is the evaluation data, and the output is the adjusted generative AI model.

[0996] Example prompt sentence:

[0997] Please suggest a recipe that meets the following criteria:

[0998] Ingredients: Pumpkin, spinach

[0999] Allergies: Wheat allergy

[1000] Budget: 500 yen

[1001] Emotional state: Stressed

[1002] Season: Autumn seasonal ingredients

[1003] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[1004] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1005] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[1006] [Third embodiment]

[1007] FIG. 5 shows an example of the configuration of a data processing system 310 according to the third embodiment.

[1008] 5, the data processing system 310 includes the data processing device 12 and a headset type terminal 314. An example of the data processing device 12 is a server.

[1009] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1010] The headset type terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a display 343. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the display 343 are also connected to the bus 52.

[1011] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[1012] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[1013] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1014] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1015] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1016] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1017] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[1018] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the headset type terminal 314 will be referred to as the "terminal."

[1019] The system of the present invention has a user, a terminal, and a server as its main components, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients, and updating the generative AI model based on the user's evaluation.

[1020] System Overview

[1021] User operations

[1022] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, a user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "I want pumpkin as a seasonal ingredient in autumn."

[1023] Sending conditions

[1024] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, which ensures data security.

[1025] Recipe Generation

[1026] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[1027] The server generates an SQL query as follows to extract the corresponding recipes from the database:

[1028] Exclude certain ingredients (e.g. garlic, wheat)

[1029] Within your budget (e.g., under 500 yen)

[1030] Prioritize seasonal ingredients (e.g. pumpkin)

[1031] Recipe presentation

[1032] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto" is displayed.

[1033] Recipe Rating

[1034] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[1035] Submitting and reviewing your evaluation

[1036] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[1037] Specific examples

[1038] For example:

[1039] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1040] 2. The device sends these conditions to the server.

[1041] 3. The server extracts recipes such as "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto" based on the conditions and sends them to the terminal.

[1042] 4. The device displays the received recipe to the user.

[1043] 5. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[1044] 6. The device sends the evaluation data to the server.

[1045] 7. The server adds the rating to the database and updates the generative AI model.

[1046] In this way, the present invention is a system that continues to suggest appropriate recipes based on the user's input conditions and evaluations.

[1047] The processing flow will be explained below.

[1048] Step 1:

[1049] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[1050] Step 2:

[1051] The terminal converts the condition data entered by the user into JSON format. For example, the data is converted as follows:

[1052] json

[1053] {

[1054] "preferences": {

[1055] "garlic": "no",

[1056] "allergies": ["wheat"],

[1057] "budget": 500,

[1058] "season_ingredient": "pumpkin"

[1059] }

[1060] }

[1061] Step 3:

[1062] The terminal sends the converted JSON data to the server using the HTTPS protocol, which ensures that the data arrives securely at the server.

[1063] Step 4:

[1064] The server parses the received JSON data, which is then broken down into fields based on the user's input (e.g., garlic, allergies, budget, season_ingredient).

[1065] Step 5:

[1066] The server generates a database query based on the parsed data to exclude certain ingredients. For example, the following SQL query is generated:

[1067] sql

[1068] SELECT FROM recipes

[1069] WHERE NOT (ingredients LIKE '%garlic%')

[1070] AND NOT (ingredients LIKE '%wheat%')

[1071] AND total_cost <= 500

[1072] AND ingredients LIKE '%pumpkin%'

[1073] ORDER BY total_rating DESC;

[1074] Step 6:

[1075] The server executes the generated query and extracts recipes from the database that match the criteria, such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto."

[1076] Step 7:

[1077] The server converts the extracted recipe data into JSON format, for example, the following JSON data is generated:

[1078] json

[1079] {

[1080] "recipes": [

[1081] {

[1082] "title": "Pumpkin and spinach gratin",

[1083] "ingredients": ["pumpkin", "spinach", ...],

[1084] "total_cost": 450,

[1085] "rating": 4.5

[1086] },

[1087] {

[1088] "title": "Pumpkin and mushroom risotto",

[1089] "ingredients": ["pumpkin", "mushroom", ...],

[1090] "total_cost": 480,

[1091] "rating": 4.7

[1092] }

[1093] ]

[1094] }

[1095] Step 8:

[1096] The server sends the converted JSON data to the terminal.

[1097] Step 9:

[1098] The device parses the received JSON data and displays it on the user interface, such as recipe information like "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto."

[1099] Step 10:

[1100] The user selects a dish from the presented recipes and actually cooks it. After cooking, the user rates the recipe in the application (e.g., 4 out of 5 stars) and adds detailed comments.

[1101] Step 11:

[1102] The terminal converts the rating data entered by the user into JSON format. For example, the data is converted as follows:

[1103] json

[1104] {

[1105] "recipe_id": 12345,

[1106] "rating": 4,

[1107] "comment": "The pumpkin flavor was strong and delicious"

[1108] }

[1109] Step 12:

[1110] The terminal transmits the converted rating data to the server using the HTTPS protocol.

[1111] Step 13:

[1112] The server analyzes the received evaluation data and adds the evaluation information of the corresponding recipe to the database.

[1113] Step 14:

[1114] The server updates the generative AI model based on the newly received evaluation data, which enables it to propose recipes that better match the user's preferences the next time recipes are generated.

[1115] Example 1

[1116] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1117] Conventional recipe suggestion systems have difficulty responding flexibly to specific user conditions and requests, and are particularly inadequate at generating recipes that take into account food allergies, budgets, and seasonal ingredients. Furthermore, they lack a mechanism for incorporating user feedback, making it difficult to regularly provide suggestions that satisfy users.

[1118] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1119] In this invention, the server includes means for accepting input conditions for specific ingredients from a user, means for transmitting the accepted conditions to a digital device, means for extracting information from a data store based on the conditions, means for presenting the extracted information to the user, means for accepting user ratings, means for transmitting the accepted ratings to the digital device and updating the generative artificial intelligence model, and means for transmitting the extracted information using a secure communication protocol. This enables more accurate recipe suggestions that correspond to the user's conditions and allows for continuous improvement that reflects the user's ratings.

[1120] "User" refers to a person who uses the system of the present invention to input specific ingredients and conditions.

[1121] "Input conditions" refer to requirements specified by the user regarding specific ingredients, allergy information, budget, seasonal ingredients, etc.

[1122] "Digital device" refers to an electronic device that receives user input, transmits it to a server, and displays the results. Examples of such devices include smartphones and tablet devices.

[1123] "Server" refers to a central control device that queries a database based on criteria received from a user and extracts, generates, and transmits relevant information.

[1124] "Information" refers to recipes and other related data extracted from a database based on user-specified criteria.

[1125] "Data store" refers to a database or storage system for storing and managing information.

[1126] "Secure communications protocol" refers to a communications method used to preserve data confidentiality and integrity, such as HTTPS.

[1127] A "generative artificial intelligence model" refers to a machine learning model that learns from user evaluation data and reflects that knowledge in its next proposal.

[1128] "Evaluation" is feedback that a user gives to a presented recipe, and includes star ratings, comments, and the like.

[1129] The present invention is a system whose main components are the user, terminal, and server. It proposes, extracts, and displays recipes based on conditions specified by the user, such as ingredients, allergy information, budget, and seasonal ingredients, and updates the generative AI model based on the user's evaluation.

[1130] System configuration

[1131] User operations

[1132] The user launches the application and inputs specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, the user inputs conditions such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[1133] Sending condition data

[1134] The terminal converts the condition data entered by the user into JSON format and transmits it securely to the server using the HTTPS protocol, thereby ensuring the confidentiality and integrity of the data.

[1135] Recipe Generation

[1136] The server parses the received JSON data and generates a database query based on the user's input criteria. Specifically, the server creates an SQL query to extract recipes that exclude specific ingredients (e.g., garlic, wheat) and prioritize seasonal ingredients (e.g., pumpkin) within budget (e.g., under 500 yen). An example of an SQL query is shown below:

[1137] sql

[1138] SELECT FROM recipes

[1139] WHERE NOT ingredients LIKE '%garlic%'

[1140] AND NOT ingredients LIKE '%wheat%'

[1141] AND price <= 500

[1142] AND ingredients LIKE '%pumpkin%'

[1143] Recipe presentation

[1144] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays the specific recipe name, required ingredients, and cooking steps on the user interface. For example, the user might be offered recipes such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto."

[1145] Recipe Rating

[1146] Users can try the recipes presented to them and then rate them in the application. Users can also provide star ratings (e.g., 4 out of 5 stars) and feedback comments.

[1147] Sending and reflecting evaluation data

[1148] The device converts the user-entered rating data into JSON format and sends it to the server using a secure communication protocol (e.g., HTTPS). The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. At the same time, the generative AI model learns from this rating data and reflects it in the next recipe suggestions.

[1149] Specific examples

[1150] For example:

[1151] 1. The user launches the application and enters the following criteria: "I don't like garlic," "I'm allergic to wheat," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1152] 2. The device converts these conditions into JSON format and sends it to the server using the HTTPS protocol.

[1153] 3. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, converts them into JSON format, and sends them to the terminal.

[1154] 4. The device analyzes the received recipe and displays it on the user interface.

[1155] 5. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[1156] 6. The device converts the evaluation data into JSON format and sends it to the server using the HTTPS protocol.

[1157] 7. The server analyzes the received evaluation data, adds the evaluation information for the corresponding recipe to the database, and updates the generative AI model.

[1158] Example prompts for generative AI models

[1159] The user has entered "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "I want pumpkin, which is a seasonal ingredient in autumn." Please suggest a recipe based on that.

[1160] In this way, the present invention is a recipe suggestion system that suggests recipes that meet the user's requirements and is capable of continuous improvement that reflects the user's evaluations.

[1161] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1162] Step 1: User input

[1163] The user launches the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, the user might specify criteria such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn." The input data is entered into the application's form.

[1164] Input: Specific ingredients, allergy information, budget, seasonal ingredients

[1165] Output: User input data

[1166] Step 2: Sending condition data

[1167] The terminal converts the condition data entered by the user into JSON format, after which the terminal transmits the data securely to the server using the HTTPS protocol, which ensures the confidentiality and integrity of the data.

[1168] Input: User-entered data

[1169] Data processing: Convert input data into JSON format

[1170] Output: Condition data in JSON format

[1171] Step 3: Generate the recipe

[1172] The server analyzes the received JSON data and generates a database query based on the user's criteria. For example, the server creates an SQL query to search for recipes that do not contain "garlic" or "wheat," that are within a budget of 500 yen, and that use "pumpkin" as a seasonal ingredient. The server executes this SQL query to extract matching recipes from the database.

[1173] Input: Condition data in JSON format

[1174] Data processing / calculation: SQL query generation and execution

[1175] Output: Recipe data

[1176] Step 4: Present the recipe

[1177] The server converts the extracted recipe data into JSON format and sends it to the device, which then analyzes the received recipe data and displays the specific recipe name, required ingredients, and cooking steps on the user interface.

[1178] Input: Recipe data

[1179] Data processing: Convert to JSON format

[1180] Output: Recipe data in JSON format

[1181] Step 5: Evaluate the recipe

[1182] The user tries the displayed recipe and enters their rating in the application. The user can write a star rating (e.g., 4 out of 5 stars) and feedback comments. This rating data is used for subsequent processing.

[1183] Input: User's recipe rating

[1184] Output: Evaluation data

[1185] Step 6: Submit and reflect evaluation data

[1186] The device converts the user-entered rating data into JSON format and sends it to the server using a secure communication protocol (e.g., HTTPS). The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. Furthermore, the generative AI model learns from this rating data and reflects it in the next recipe suggestions.

[1187] Input: Evaluation data

[1188] Data processing: Convert to JSON format and analyze

[1189] Output: Updated recipe rating information and generative AI model

[1190] In this way, the system can tailor recipe suggestions to the user's requirements and continuously improve based on user feedback.

[1191] (Application example 1)

[1192] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1193] Conventional recipe suggestion systems only provide recipes based on the user's ingredient requirements, and lack a mechanism for using user ratings to improve the system's suggestion accuracy. Furthermore, when suggesting ingredients or recipes, links to where users can purchase the ingredients are often not provided, making it difficult to take immediate action. Furthermore, even when suggesting recipes that take seasonal ingredients or budget into consideration, such information cannot be systematically incorporated. This has prevented the system from improving user convenience and satisfaction.

[1194] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1195] In this invention, the server includes a means for accepting input conditions for specific ingredients from a user, a means for transmitting the accepted conditions to the server, a means for extracting recipes from a database based on the conditions, a means for presenting the extracted recipes to the user and displaying links where the corresponding ingredients and recipes can be purchased together, a means for accepting user ratings, and a means for transmitting the accepted ratings to the server and updating the generative AI model. This allows users to obtain recipes that meet their ingredient requirements and immediately purchase related ingredients. Furthermore, by improving the system based on user ratings, users can receive more accurate suggestions.

[1196] A "user" is a consumer who utilizes the system and provides input requirements regarding a particular food ingredient.

[1197] "Input conditions" refers to information such as specific ingredients, allergy information, budget, and seasonal ingredients that the user provides to the system.

[1198] The "server" is a central computer system that processes data based on the conditions received from the user, proposes recipes, and evaluates them.

[1199] "Means for extracting recipes from a database based on conditions" refers to the function of the server searching and extracting recipes from a database that meet the conditions provided by the user.

[1200] "Means for presenting extracted recipes to the user" refers to a function for the server to provide the extracted recipes to the user in an easy-to-view format.

[1201] "Means for displaying a link where the relevant ingredients and recipe can be purchased together" refers to a function that displays a link where the user can simultaneously purchase the recipe provided by the system and the ingredients related to it.

[1202] The "means for accepting user ratings" refers to a function that allows a user to input a rating for a recipe that they have tried.

[1203] "Means for updating the generative AI model" refers to the function of adjusting the AI ​​model based on user evaluation data and reflecting this in the next recipe suggestion.

[1204] The "JSON format" is a lightweight data exchange format for exchanging user input conditions and data between applications.

[1205] The system for implementing this invention consists primarily of a user, a terminal, and a server. The user specifies input conditions using the terminal, and the server generates and presents recipes based on those conditions. The system also improves by updating the generative AI model based on user evaluations.

[1206] Program processing explanation

[1207] 1. User operations

[1208] Users open the application and input criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal for under 500 yen," and "I want pumpkin as a seasonal ingredient in autumn." This input is based on the user's preferences and specific constraints.

[1209] 2. Submitting the conditions

[1210] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, ensuring secure data transmission.

[1211] 3. Recipe Generation

[1212] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[1213] 4. Presenting the recipe

[1214] The server extracts the relevant recipes from the database, converts the data into JSON format, and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto" is displayed, along with links to purchase the corresponding ingredients and recipes.

[1215] 5. Recipe Rating

[1216] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[1217] 6. Submitting and Reflecting Ratings

[1218] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[1219] Hardware / Software used

[1220] Device: Smartphone

[1221] Software: Commercially available browsers and dedicated applications

[1222] Server: Python, Flask (server side), SQL database

[1223] Examples of concrete examples and prompts

[1224] Examples:

[1225] The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal autumn ingredient." The device sends these criteria to the server. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the criteria and sends them to the device. The device displays the received recipes to the user, along with links to purchase related ingredients. The user makes "Pumpkin and spinach gratin" and rates it four stars. The device sends the rating data to the server, which adds the rating to a database and updates the generative AI model.

[1226] Example prompt sentence:

[1227] "Please suggest recipes based on specific ingredient conditions entered by the user. The conditions are: I don't like garlic, I have a wheat allergy, the cost is under 500 yen per meal, and pumpkin is a seasonal ingredient in autumn."

[1228] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1229] Step 1:

[1230] Users launch the smartphone application and input criteria such as specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, users might input criteria such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn."

[1231] (Input) Condition data entered by the user

[1232] (Output) Prepare smartphone device for data transmission

[1233] Step 2:

[1234] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, ensuring data security during this process.

[1235] (Input) Condition data entered by the user (text format)

[1236] (Output) JSON format data sent to the server

[1237] Step 3:

[1238] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[1239] (Input) Condition data in JSON format received by the server

[1240] (Output) Generated SQL query

[1241] Step 4:

[1242] The server uses the generated SQL query to extract the corresponding recipes from the database. The extracted recipe information includes details such as the recipe name, ingredients, and cooking instructions.

[1243] (Input) Generated SQL query

[1244] (Output) Recipe information extracted from the database

[1245] Step 5:

[1246] The server converts the extracted recipe into JSON format and sends it to the terminal using the HTTPS protocol.

[1247] (Input) Recipe information extracted from the database

[1248] (Output) JSON format recipe data sent to the device

[1249] Step 6:

[1250] The device parses the JSON-formatted recipe data received from the server and displays it in a user interface, including the recipe name, ingredient list, detailed instructions, and links to purchase the associated ingredients and recipe.

[1251] (Input) JSON format recipe data received from the server

[1252] (Output) Recipe information and purchase link displayed in the user interface

[1253] Step 7:

[1254] Users try the displayed recipes and provide a rating within the application, including a star rating (e.g., 4 out of 5 stars) and detailed comments.

[1255] (Input) User rating data (star ratings and comments)

[1256] (Output) Prepare smartphone device for data transmission

[1257] Step 8:

[1258] The terminal converts the evaluation data entered by the user into JSON format and sends it to the server again using the HTTPS protocol.

[1259] (Input) User evaluation data (text format)

[1260] (Output) JSON formatted rating data sent to the server

[1261] Step 9:

[1262] The server analyzes the received evaluation data and adds the corresponding recipe evaluation information to the database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[1263] (Input) JSON formatted rating data received by the server

[1264] (Output) Evaluation information and updated generative AI model added to the database

[1265] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1266] The system of the present invention has as its main components the user, a terminal, a server, and an emotion engine, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients and their emotional state, and updating the generative AI model based on the user's evaluation of these recipes.

[1267] System Overview

[1268] User operations

[1269] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, the user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn." At the same time, data (images, voice, text, etc.) can be input at the same time for the emotion engine to analyze the user's emotions.

[1270] Sending Conditions and Emotion Data

[1271] The device converts the condition data and emotion data entered by the user into JSON format and sends it to the server using the HTTPS protocol, thereby ensuring data security.

[1272] Recipe Generation

[1273] The server analyzes the received JSON data and generates a database query based on the conditions entered by the user. The emotion engine also analyzes the provided emotion data to understand the user's current emotional state. For example, if the user is feeling stressed, the generative AI model is adjusted to suggest recipes appropriate for that emotional state (such as recipes using ingredients with a relaxing effect). Specifically, the SQL query is generated as follows:

[1274] Exclude certain ingredients (e.g. garlic, wheat)

[1275] Within your budget (e.g., under 500 yen)

[1276] Prioritize seasonal ingredients (e.g. pumpkin)

[1277] Consider ingredients that correspond to your emotional state (e.g., ingredients that have a relaxing effect)

[1278] Recipe presentation

[1279] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto" is displayed. In addition, information related to the user's emotional state is also presented.

[1280] Recipe Rating

[1281] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[1282] Submitting and reviewing your evaluation

[1283] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected the next time a recipe is generated. The emotion engine also uses the user's evaluation data to improve the accuracy of its emotional state analysis.

[1284] Specific examples

[1285] For example:

[1286] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1287] 2. The user uses a facial recognition camera to input their current emotional state (e.g., feeling stressed).

[1288] 3. The device sends the condition data and emotion data to the server.

[1289] 4. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, and prioritizes recipes with a relaxing effect based on the analysis results of the emotion engine.

[1290] 5. The extracted recipe is sent to the terminal and displayed to the user.

[1291] 6. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[1292] 7. The device sends the evaluation data to the server.

[1293] 8. The server adds the rating to the database and updates the generative AI model and emotion engine.

[1294] In this way, the present invention is a system that suggests appropriate recipes according to the user's input conditions and emotional state.

[1295] The processing flow will be explained below.

[1296] Step 1:

[1297] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[1298] Step 2:

[1299] Users input their current emotional state using an emotion-detecting camera and microphone. The emotion-detecting camera analyzes the user's facial expressions, and the microphone analyzes the user's vocal tone.

[1300] Step 3:

[1301] The device converts the condition data and emotion data entered by the user into JSON format. An example of the converted data is as follows:

[1302] json

[1303] {

[1304] "preferences": {

[1305] "garlic": "no",

[1306] "allergies": ["wheat"],

[1307] "budget": 500,

[1308] "season_ingredient": "pumpkin"

[1309] },

[1310] "emotion": {

[1311] "stress_level": "high",

[1312] "mood": "anxious"

[1313] }

[1314] }

[1315] Step 4:

[1316] The terminal sends the converted JSON data to the server using the HTTPS protocol, which ensures that the data arrives securely at the server.

[1317] Step 5:

[1318] The server parses the received JSON data, which is then broken down into fields based on the user's input (e.g., garlic, allergies, budget, season_ingredient) and emotional states (e.g., stress_level, mood).

[1319] Step 6:

[1320] The server generates a database query based on the parsed data to exclude certain ingredients. For example, the following SQL query is generated:

[1321] sql

[1322] SELECT FROM recipes

[1323] WHERE NOT (ingredients LIKE '%garlic%')

[1324] AND NOT (ingredients LIKE '%wheat%')

[1325] AND total_cost <= 500

[1326] AND ingredients LIKE '%pumpkin%'

[1327] ORDER BY total_rating DESC;

[1328] Step 7:

[1329] The server uses an emotion engine to evaluate the user's emotional state and prioritizes ingredients and recipes that have a relaxing effect. The emotion engine prioritizes recipes that contain ingredients that reduce stress (e.g., chamomile, lavender).

[1330] Step 8:

[1331] The server executes the generated query and extracts recipes from the database that match the criteria, such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto."

[1332] Step 9:

[1333] The server converts the extracted recipe data into JSON format, for example, the following JSON data is generated:

[1334] json

[1335] {

[1336] "recipes": [

[1337] {

[1338] "title": "Pumpkin and spinach gratin",

[1339] "ingredients": ["pumpkin", "spinach", ...],

[1340] "total_cost": 450,

[1341] "rating": 4.5,

[1342] "emotion_suitability": "high"

[1343] },

[1344] {

[1345] "title": "Pumpkin and mushroom risotto",

[1346] "ingredients": ["pumpkin", "mushroom", ...],

[1347] "total_cost": 480,

[1348] "rating": 4.7,

[1349] "emotion_suitability": "medium"

[1350] }

[1351] ]

[1352] }

[1353] Step 10:

[1354] The server sends the converted JSON data to the terminal.

[1355] Step 11:

[1356] The device parses the received JSON data and displays it in the user interface. For example, it displays recipe information such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto," as well as information related to the user's emotional state (e.g., "highly relaxing").

[1357] Step 12:

[1358] The user selects a dish from the presented recipes and actually cooks it. After cooking, the user rates the recipe in the application (e.g., 4 out of 5 stars) and enters detailed comments.

[1359] Step 13:

[1360] The device converts the rating data entered by the user into JSON format and sends it to the server. For example, the data is converted as follows:

[1361] json

[1362] {

[1363] "recipe_id": 12345,

[1364] "rating": 4,

[1365] "comment": "The pumpkin flavor was strong and delicious",

[1366] "emotion_feedback": {

[1367] "relaxation_effect": "high",

[1368] "mood_improvement": "significant"

[1369] }

[1370] }

[1371] Step 14:

[1372] The server analyzes the received evaluation data and adds the evaluation information of the corresponding recipe to the database.

[1373] Step 15:

[1374] The server updates the generative AI model and emotion engine based on the newly received evaluation data, allowing it to propose recipes that better match the user's emotional state and preferences the next time recipes are generated.

[1375] Example 2

[1376] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1377] In today's lifestyles, users often find it difficult to find suitable recipes that take into account ingredients, allergies, budgets, and seasonal ingredients. Taking the user's emotional state into account would also enable more satisfying recipe suggestions, but this has been difficult to achieve with conventional systems. Furthermore, the lack of a feedback function that reflects the user's evaluation of the recipe and improves the next suggestions means that user satisfaction does not improve over the long term.

[1378] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1379] In this invention, the server includes means for accepting user input conditions, means for transmitting the conditions to the server, means for generating a database query, means including an emotion engine for adjusting recipes based on the user's emotional state, means for extracting recipes from the database based on the conditions and the emotional state, means for presenting recipes to the user, means for accepting user ratings, and means for transmitting the ratings to the server and updating the generative AI model. This makes it possible to propose appropriate recipes based on the user's input conditions and emotional state, and realizes system improvements based on ratings.

[1380] A "user" is a person who uses this system to input ingredients and conditions, and makes recipe suggestions and evaluations.

[1381] "Input conditions" is information that allows the user to specify specific ingredients, allergy information, budget, seasonal ingredients, and the like.

[1382] The "server" is a central processing unit that processes the received information, generates database queries, extracts recipes, runs the emotion engine, and collects and processes rating data.

[1383] A "database query" is a query statement that the server generates to extract recipes that meet the user's requirements from the database.

[1384] The "Emotion Engine" is a system that analyzes the user's emotional state and suggests recipes that are appropriate for that state.

[1385] A "recipe" is a cooking instruction manual that includes information such as ingredients, steps, and cooking time.

[1386] "Evaluation" refers to the act of a user providing feedback on a presented recipe in the form of a star rating, a comment, or the like.

[1387] A "generative AI model" is an artificial intelligence model that suggests and adjusts recipes based on the data it receives.

[1388] The system of this invention has as its main components the user, a terminal, a server, and an emotion engine, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients and their emotional state, and for updating the generative AI model based on the user's evaluation of these recipes.

[1389] First, the user opens the application and inputs criteria such as a specific food ingredient (e.g., pumpkin), allergy information (e.g., garlic dislike, wheat allergy), budget (e.g., under 500 yen), and seasonal ingredients (e.g., pumpkin in autumn). The user also uses an input device such as a camera or microphone to input their current emotional state (e.g., feeling stressed). This information is captured by the application as text input, image, or voice data.

[1390] Next, the device converts the condition data and emotion data entered by the user into JSON format. This process is performed by the data conversion module. The converted data is sent to the server using the HTTPS protocol. Using the HTTPS protocol encrypts the data and maintains security.

[1391] The server analyzes the received JSON data and generates a database query based on the conditions entered by the user. The server's internal SQL query generation module generates an appropriate query based on the request. The emotion engine also analyzes the provided emotion data (e.g., image recognition, voice recognition) to understand the user's current emotional state. Based on this information, the generative AI model filters recipes that match the user's emotions.

[1392] For example, the following SQL query is generated: SELECT FROM recipe WHERE ingredients NOT IN ('garlic', 'wheat') AND budget <= 500 AND season = 'autumn'. The emotion engine analyzes the emotion data and determines the user's emotional state (e.g., "high stress").

[1393] The server then converts the extracted recipe data into JSON format and sends it to the device. The device parses the received JSON data and displays the recipe information on the user interface. The user can view a list of suggested recipes, including recipes such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto." Information related to the user's emotional state is also displayed.

[1394] The user tries the presented recipe and enters their rating in the application, for example, by entering a star rating (e.g., 4 stars) or a detailed comment (e.g., "It was delicious, but a little salty"). The device converts the user-entered rating data into JSON format and sends it to the server.

[1395] The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. The generative AI model is adjusted based on this rating data and reflected in the next recipe generation. The emotion engine also uses user rating data to improve the accuracy of emotional state analysis.

[1396] Here are some examples of prompts:

[1397] 1. "Please suggest recipes that use specific ingredients (e.g., pumpkin, spinach). Also, please take into consideration allergy information (e.g., wheat allergy), budget (e.g., under 500 yen), and seasonal ingredients, and prioritize recipes that have a relaxing effect."

[1398] 2. "The user is feeling stressed. Please suggest some recipes that will help them relax."

[1399] In this way, the present invention is a system that proposes appropriate recipes based on the user's input conditions and emotional state, and repeats the process of improving the system based on evaluations.

[1400] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1401] Step 1:

[1402] The user launches the application and inputs criteria such as ingredients, allergy information, budget, and seasonal ingredients. For example, they can input information such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn." The user also uses a camera or microphone to input their emotional state. The input data is then imported into the application as text, images, and audio data.

[1403] Step 2:

[1404] The device converts the condition data and emotion data entered by the user into JSON format. The converted data (input: user's condition data and emotion data, output: JSON format data) is then sent to the server using the HTTPS protocol. This ensures that the data is encrypted before transmission, ensuring security.

[1405] Step 3:

[1406] The server parses the received JSON data. First, the data parser breaks the JSON data into individual elements and extracts the conditions entered by the user (input: JSON data, output: parsed condition data). Next, the database query generation module generates an SQL query based on the condition data (e.g., "SELECT FROM recipe WHERE ingredients NOT IN ('garlic', 'wheat') AND budget <= 500 AND season = 'Autumn'"). Finally, the emotion engine parses the emotion data and determines the user's emotional state.

[1407] Step 4:

[1408] The emotion engine interprets the user's emotional state based on the provided emotion data and reflects the result (e.g., "high stress") in the extracted recipes. Specifically, the emotion engine adjusts the generative AI model to prioritize recipes containing ingredients that are good for stress (input: analyzed emotion data, output: adjusted recipe query).

[1409] Step 5:

[1410] The server converts the recipe data extracted from the database into JSON format and sends it to the device (input: extracted recipe data, output: recipe data converted into JSON format). By doing this, the server makes it easier for the device to analyze the data it receives.

[1411] Step 6:

[1412] The device analyzes the received JSON data and displays the recipe information on the user interface. Specifically, the device breaks down the JSON data into recipe names, ingredients, cooking procedures, etc., and provides them to the user in a visually easy-to-understand format (input: recipe data in JSON format, output: recipe information displayed on the interface).

[1413] Step 7:

[1414] The user tries the presented recipe and inputs their rating into the application, for example, by giving a star rating (e.g., four stars) or a comment (e.g., "It was delicious, but a little salty") (Input: Thoughts and rating on the recipe, Output: Rating data).

[1415] Step 8:

[1416] The device converts the evaluation data received from the user into JSON format and sends it to the server (input: evaluation data, output: JSON-formatted evaluation data). The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. The generative AI model is also adjusted based on this evaluation data, and this is reflected the next time a recipe is generated (input: JSON-formatted evaluation data, output: updated generative AI model).

[1417] (Application example 2)

[1418] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1419] Conventional recipe suggestion systems only suggest recipes based on the user's input of ingredients, but do not consider the user's emotional state, failing to address the emotional needs of users. Furthermore, they lack an interface for inputting ingredients and emotional state in a physical store. As a result, users lack a way to obtain optimal recipes in stressful situations, reducing the overall convenience and satisfaction of the system.

[1420] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1421] In this invention, the server includes means for accepting input conditions for specific ingredients from a user, means for transmitting the accepted conditions to the server, means for extracting recipes from a database based on the conditions, means for presenting the extracted recipes to the user, means for accepting a user rating, means for transmitting the accepted rating to the server and updating the generative AI model, means for recognizing the user's emotional state, and means for adjusting the recipe based on the emotional state, thereby enabling the server to propose recipes optimized for the user's emotional state and ingredient conditions.

[1422] "User" refers to any individual or entity that uses the System.

[1423] "Specific ingredients" refers to one or more ingredients designated by the user.

[1424] "Input conditions" are conditions that the user specifies to the system, and include specific ingredients, allergy information, budget, seasonal ingredients, and the like.

[1425] "Server" refers to a computer system that processes data received from users and generates recipes in conjunction with a database.

[1426] "Database" refers to a collection of information that stores recipe information.

[1427] "Emotion engine" refers to a software module for recognizing and analyzing a user's emotional state.

[1428] A "recipe" refers to information that includes steps and ingredients needed to prepare a dish.

[1429] "Generative AI model" refers to a recipe model that is generated based on data obtained from the user.

[1430] "Facial recognition technology" refers to technology that uses a camera to identify a user's face and analyze their emotional state.

[1431] The "in-store mode" is a mode intended for use in a physical store, and includes a function that shows where to obtain the selected ingredients.

[1432] "Rating" refers to the feedback a user gives to a suggested recipe.

[1433] "JSON format" stands for JavaScript Object Notation, a lightweight data exchange format.

[1434] The present invention is a system that suggests recipes based on input conditions and emotional state of a user regarding specific ingredients, and is configured as follows.

[1435] 1. User Operation

[1436] Using a smartphone application, users input criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. Using facial recognition technology, users can also input their emotional state at the same time. For example, a user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1437] 2. Data transmission

[1438] The user's device converts the received condition data and emotion data into JSON format and sends it to the server using the HTTPS protocol, thereby maintaining data security.

[1439] 3. Recipe Generation

[1440] The server parses the received JSON data and generates a database query based on the conditions entered by the user. The emotion engine also analyzes the provided emotion data to understand the user's current emotional state. For example, if the user is feeling stressed, the generative AI model is adjusted to suggest recipes appropriate for that emotional state (such as recipes using ingredients with a relaxing effect). The SQL query is generated as follows:

[1441] Exclude certain ingredients (e.g. garlic, wheat)

[1442] Within your budget (e.g., under 500 yen)

[1443] Prioritize seasonal ingredients (e.g. pumpkin)

[1444] Consider ingredients that correspond to your emotional state (e.g., ingredients that have a relaxing effect)

[1445] 4. Presenting the recipe

[1446] The server converts the extracted recipe data into JSON format and sends it to the user's device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto" is displayed. In addition, information related to the user's emotional state is also presented.

[1447] 5. Recipe Rating

[1448] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[1449] 6. Sending and Reflecting Evaluation Data

[1450] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected the next time a recipe is generated. The emotion engine also uses the user's evaluation data to improve the accuracy of its emotional state analysis.

[1451] Hardware and software used

[1452] Hardware: Smartphone (with built-in camera)

[1453] Software: Smartphone application, OpenCV, EmotionRecognizer, server (including database), HTTPS protocol, generative AI model, emotion engine

[1454] Specific examples of possible uses include:

[1455] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1456] 2. The user uses a facial recognition camera to input their current emotional state (e.g., feeling stressed).

[1457] 3. The device sends the condition data and emotion data to the server.

[1458] 4. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, and prioritizes recipes with a relaxing effect based on the analysis results of the emotion engine.

[1459] 5. The extracted recipe is sent to the terminal and displayed to the user.

[1460] 6. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[1461] 7. The device sends the evaluation data to the server.

[1462] 8. The server adds the rating to the database and updates the generative AI model and emotion engine.

[1463] Example prompt sentence:

[1464] Please suggest a recipe that meets the following criteria:

[1465] Ingredients: Pumpkin, spinach

[1466] Allergies: Wheat allergy

[1467] Budget: 500 yen

[1468] Emotional state: Stressed

[1469] Season: Autumn seasonal ingredients

[1470] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1471] Step 1:

[1472] The user starts the smartphone application and selects "physical store mode." Next, they input the ingredients they want to purchase (e.g., pumpkin and spinach). The input ingredient data is temporarily saved in the application.

[1473] Step 2:

[1474] The user inputs their emotional state using facial recognition technology. By activating the camera and capturing their face, the EmotionRecognizer module analyzes their emotions. The analyzed emotional data (e.g., feeling stressed) is generated. This emotional data is temporarily stored along with the food ingredient data.

[1475] Step 3:

[1476] The terminal compiles the information entered by the user, such as ingredient information, emotional data, allergy information, budget, and seasonal ingredients, and converts it into JSON format. The converted data is sent to the server using the HTTPS protocol. The input is the user data, and the output is the JSON data sent to the server.

[1477] Step 4:

[1478] The server parses the received JSON data. It generates a database query based on the input criteria and extracts matching recipes from the recipe database. Specifically, the following filtering is applied: exclude specific ingredients, stay within budget, prioritize seasonal ingredients, and consider ingredients according to emotional state. The input is JSON data, and the output is the filtered recipe data.

[1479] Step 5:

[1480] The server's emotion engine adjusts the generative AI model based on the analyzed emotion data to prioritize recipes that suit the user's emotional state. The generative AI model is configured to recommend recipes that use ingredients with a relaxing effect, for example. The input is emotion data, and the output is adjusted recipe data.

[1481] Step 6:

[1482] The server converts the extracted and adjusted recipe data into JSON format and sends it to the terminal. The terminal parses the received JSON data and displays the recipe information on the user interface. Specifically, it displays recipes such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto." The input is the recipe data, and the output is the displayed recipe information.

[1483] Step 7:

[1484] Users try the displayed recipes and enter a rating (e.g., four stars) and comments in the application. This rating data is temporarily stored on the device.

[1485] Step 8:

[1486] The device converts the evaluation data entered by the user into JSON format and sends it to the server using the HTTPS protocol. The server analyzes the received evaluation data and adds it to a database as evaluation information for the corresponding recipe. Furthermore, the generative AI model is adjusted using this evaluation data and reflected the next time a recipe is generated. The input is the evaluation data, and the output is the adjusted generative AI model.

[1487] Example prompt sentence:

[1488] Please suggest a recipe that meets the following criteria:

[1489] Ingredients: Pumpkin, spinach

[1490] Allergies: Wheat allergy

[1491] Budget: 500 yen

[1492] Emotional state: Stressed

[1493] Season: Autumn seasonal ingredients

[1494] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[1495] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1496] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[1497] [Fourth embodiment]

[1498] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[1499] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

[1500] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1501] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[1502] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[1503] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[1504] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1505] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1506] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1507] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1508] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1509] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[1510] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1511] The system of the present invention has a user, a terminal, and a server as its main components, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients, and updating the generative AI model based on the user's evaluation.

[1512] System Overview

[1513] User operations

[1514] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, a user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "I want pumpkin as a seasonal ingredient in autumn."

[1515] Sending conditions

[1516] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, which ensures data security.

[1517] Recipe Generation

[1518] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[1519] The server generates an SQL query as follows to extract the corresponding recipes from the database:

[1520] Exclude certain ingredients (e.g. garlic, wheat)

[1521] Within your budget (e.g., under 500 yen)

[1522] Prioritize seasonal ingredients (e.g. pumpkin)

[1523] Recipe presentation

[1524] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto" is displayed.

[1525] Recipe Rating

[1526] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[1527] Submitting and reviewing your evaluation

[1528] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[1529] Specific examples

[1530] For example:

[1531] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1532] 2. The device sends these conditions to the server.

[1533] 3. The server extracts recipes such as "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto" based on the conditions and sends them to the terminal.

[1534] 4. The device displays the received recipe to the user.

[1535] 5. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[1536] 6. The device sends the evaluation data to the server.

[1537] 7. The server adds the rating to the database and updates the generative AI model.

[1538] In this way, the present invention is a system that continues to suggest appropriate recipes based on the user's input conditions and evaluations.

[1539] The processing flow will be explained below.

[1540] Step 1:

[1541] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[1542] Step 2:

[1543] The terminal converts the condition data entered by the user into JSON format. For example, the data is converted as follows:

[1544] json

[1545] {

[1546] "preferences": {

[1547] "garlic": "no",

[1548] "allergies": ["wheat"],

[1549] "budget": 500,

[1550] "season_ingredient": "pumpkin"

[1551] }

[1552] }

[1553] Step 3:

[1554] The terminal sends the converted JSON data to the server using the HTTPS protocol, which ensures that the data arrives securely at the server.

[1555] Step 4:

[1556] The server parses the received JSON data, which is then broken down into fields based on the user's input (e.g., garlic, allergies, budget, season_ingredient).

[1557] Step 5:

[1558] The server generates a database query based on the parsed data to exclude certain ingredients. For example, the following SQL query is generated:

[1559] sql

[1560] SELECT FROM recipes

[1561] WHERE NOT (ingredients LIKE '%garlic%')

[1562] AND NOT (ingredients LIKE '%wheat%')

[1563] AND total_cost <= 500

[1564] AND ingredients LIKE '%pumpkin%'

[1565] ORDER BY total_rating DESC;

[1566] Step 6:

[1567] The server executes the generated query and extracts recipes from the database that match the criteria, such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto."

[1568] Step 7:

[1569] The server converts the extracted recipe data into JSON format, for example, the following JSON data is generated:

[1570] json

[1571] {

[1572] "recipes": [

[1573] {

[1574] "title": "Pumpkin and spinach gratin",

[1575] "ingredients": ["pumpkin", "spinach", ...],

[1576] "total_cost": 450,

[1577] "rating": 4.5

[1578] },

[1579] {

[1580] "title": "Pumpkin and mushroom risotto",

[1581] "ingredients": ["pumpkin", "mushroom", ...],

[1582] "total_cost": 480,

[1583] "rating": 4.7

[1584] }

[1585] ]

[1586] }

[1587] Step 8:

[1588] The server sends the converted JSON data to the terminal.

[1589] Step 9:

[1590] The device parses the received JSON data and displays it on the user interface, such as recipe information like "Pumpkin and spinach gratin" or "Pumpkin and mushroom risotto."

[1591] Step 10:

[1592] The user selects a dish from the presented recipes and actually cooks it. After cooking, the user rates the recipe in the application (e.g., 4 out of 5 stars) and adds detailed comments.

[1593] Step 11:

[1594] The terminal converts the rating data entered by the user into JSON format. For example, the data is converted as follows:

[1595] json

[1596] {

[1597] "recipe_id": 12345,

[1598] "rating": 4,

[1599] "comment": "The pumpkin flavor was strong and delicious"

[1600] }

[1601] Step 12:

[1602] The terminal transmits the converted rating data to the server using the HTTPS protocol.

[1603] Step 13:

[1604] The server analyzes the received evaluation data and adds the evaluation information of the corresponding recipe to the database.

[1605] Step 14:

[1606] The server updates the generative AI model based on the newly received evaluation data, which enables it to propose recipes that better match the user's preferences the next time recipes are generated.

[1607] Example 1

[1608] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1609] Conventional recipe suggestion systems have difficulty responding flexibly to specific user conditions and requests, and are particularly inadequate at generating recipes that take into account food allergies, budgets, and seasonal ingredients. Furthermore, they lack a mechanism for incorporating user feedback, making it difficult to regularly provide suggestions that satisfy users.

[1610] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1611] In this invention, the server includes means for accepting input conditions for specific ingredients from a user, means for transmitting the accepted conditions to a digital device, means for extracting information from a data store based on the conditions, means for presenting the extracted information to the user, means for accepting user ratings, means for transmitting the accepted ratings to the digital device and updating the generative artificial intelligence model, and means for transmitting the extracted information using a secure communication protocol. This enables more accurate recipe suggestions that correspond to the user's conditions and allows for continuous improvement that reflects the user's ratings.

[1612] "User" refers to a person who uses the system of the present invention to input specific ingredients and conditions.

[1613] "Input conditions" refer to requirements specified by the user regarding specific ingredients, allergy information, budget, seasonal ingredients, etc.

[1614] "Digital device" refers to an electronic device that receives user input, transmits it to a server, and displays the results. Examples of such devices include smartphones and tablet devices.

[1615] "Server" refers to a central control device that queries a database based on criteria received from a user and extracts, generates, and transmits relevant information.

[1616] "Information" refers to recipes and other related data extracted from a database based on user-specified criteria.

[1617] "Data store" refers to a database or storage system for storing and managing information.

[1618] "Secure communications protocol" refers to a communications method used to preserve data confidentiality and integrity, such as HTTPS.

[1619] A "generative artificial intelligence model" refers to a machine learning model that learns from user evaluation data and reflects that knowledge in its next proposal.

[1620] "Evaluation" is feedback that a user gives to a presented recipe, and includes star ratings, comments, and the like.

[1621] The present invention is a system whose main components are the user, terminal, and server. It proposes, extracts, and displays recipes based on conditions specified by the user, such as ingredients, allergy information, budget, and seasonal ingredients, and updates the generative AI model based on the user's evaluation.

[1622] System configuration

[1623] User operations

[1624] The user launches the application and inputs specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, the user inputs conditions such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[1625] Sending condition data

[1626] The terminal converts the condition data entered by the user into JSON format and transmits it securely to the server using the HTTPS protocol, thereby ensuring the confidentiality and integrity of the data.

[1627] Recipe Generation

[1628] The server parses the received JSON data and generates a database query based on the user's input criteria. Specifically, the server creates an SQL query to extract recipes that exclude specific ingredients (e.g., garlic, wheat) and prioritize seasonal ingredients (e.g., pumpkin) within budget (e.g., under 500 yen). An example of an SQL query is shown below:

[1629] sql

[1630] SELECT FROM recipes

[1631] WHERE NOT ingredients LIKE '%garlic%'

[1632] AND NOT ingredients LIKE '%wheat%'

[1633] AND price <= 500

[1634] AND ingredients LIKE '%pumpkin%'

[1635] Recipe presentation

[1636] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays the specific recipe name, required ingredients, and cooking steps on the user interface. For example, the user might be offered recipes such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto."

[1637] Recipe Rating

[1638] Users can try the recipes presented to them and then rate them in the application. Users can also provide star ratings (e.g., 4 out of 5 stars) and feedback comments.

[1639] Sending and reflecting evaluation data

[1640] The device converts the user-entered rating data into JSON format and sends it to the server using a secure communication protocol (e.g., HTTPS). The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. At the same time, the generative AI model learns from this rating data and reflects it in the next recipe suggestions.

[1641] Specific examples

[1642] For example:

[1643] 1. The user launches the application and enters the following criteria: "I don't like garlic," "I'm allergic to wheat," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1644] 2. The device converts these conditions into JSON format and sends it to the server using the HTTPS protocol.

[1645] 3. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, converts them into JSON format, and sends them to the terminal.

[1646] 4. The device analyzes the received recipe and displays it on the user interface.

[1647] 5. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[1648] 6. The device converts the evaluation data into JSON format and sends it to the server using the HTTPS protocol.

[1649] 7. The server analyzes the received evaluation data, adds the evaluation information for the corresponding recipe to the database, and updates the generative AI model.

[1650] Example prompts for generative AI models

[1651] The user has entered "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "I want pumpkin, which is a seasonal ingredient in autumn." Please suggest a recipe based on that.

[1652] In this way, the present invention is a recipe suggestion system that suggests recipes that meet the user's requirements and is capable of continuous improvement that reflects the user's evaluations.

[1653] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1654] Step 1: User input

[1655] The user launches the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, the user might specify criteria such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn." The input data is entered into the application's form.

[1656] Input: Specific ingredients, allergy information, budget, seasonal ingredients

[1657] Output: User input data

[1658] Step 2: Sending condition data

[1659] The terminal converts the condition data entered by the user into JSON format, after which the terminal transmits the data securely to the server using the HTTPS protocol, which ensures the confidentiality and integrity of the data.

[1660] Input: User-entered data

[1661] Data processing: Convert input data into JSON format

[1662] Output: Condition data in JSON format

[1663] Step 3: Generate the recipe

[1664] The server analyzes the received JSON data and generates a database query based on the user's criteria. For example, the server creates an SQL query to search for recipes that do not contain "garlic" or "wheat," that are within a budget of 500 yen, and that use "pumpkin" as a seasonal ingredient. The server executes this SQL query to extract matching recipes from the database.

[1665] Input: Condition data in JSON format

[1666] Data processing / calculation: SQL query generation and execution

[1667] Output: Recipe data

[1668] Step 4: Present the recipe

[1669] The server converts the extracted recipe data into JSON format and sends it to the device, which then analyzes the received recipe data and displays the specific recipe name, required ingredients, and cooking steps on the user interface.

[1670] Input: Recipe data

[1671] Data processing: Convert to JSON format

[1672] Output: Recipe data in JSON format

[1673] Step 5: Evaluate the recipe

[1674] The user tries the displayed recipe and enters their rating in the application. The user can write a star rating (e.g., 4 out of 5 stars) and feedback comments. This rating data is used for subsequent processing.

[1675] Input: User's recipe rating

[1676] Output: Evaluation data

[1677] Step 6: Submit and reflect evaluation data

[1678] The device converts the user-entered rating data into JSON format and sends it to the server using a secure communication protocol (e.g., HTTPS). The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. Furthermore, the generative AI model learns from this rating data and reflects it in the next recipe suggestions.

[1679] Input: Evaluation data

[1680] Data processing: Convert to JSON format and analyze

[1681] Output: Updated recipe rating information and generative AI model

[1682] In this way, the system can tailor recipe suggestions to the user's requirements and continuously improve based on user feedback.

[1683] (Application example 1)

[1684] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1685] Conventional recipe suggestion systems only provide recipes based on the user's ingredient requirements, and lack a mechanism for using user ratings to improve the system's suggestion accuracy. Furthermore, when suggesting ingredients or recipes, links to where users can purchase the ingredients are often not provided, making it difficult to take immediate action. Furthermore, even when suggesting recipes that take seasonal ingredients or budget into consideration, such information cannot be systematically incorporated. This has prevented the system from improving user convenience and satisfaction.

[1686] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1687] In this invention, the server includes a means for accepting input conditions for specific ingredients from a user, a means for transmitting the accepted conditions to the server, a means for extracting recipes from a database based on the conditions, a means for presenting the extracted recipes to the user and displaying links where the corresponding ingredients and recipes can be purchased together, a means for accepting user ratings, and a means for transmitting the accepted ratings to the server and updating the generative AI model. This allows users to obtain recipes that meet their ingredient requirements and immediately purchase related ingredients. Furthermore, by improving the system based on user ratings, users can receive more accurate suggestions.

[1688] A "user" is a consumer who utilizes the system and provides input requirements regarding a particular food ingredient.

[1689] "Input conditions" refers to information such as specific ingredients, allergy information, budget, and seasonal ingredients that the user provides to the system.

[1690] The "server" is a central computer system that processes data based on the conditions received from the user, proposes recipes, and evaluates them.

[1691] "Means for extracting recipes from a database based on conditions" refers to the function of the server searching and extracting recipes from a database that meet the conditions provided by the user.

[1692] "Means for presenting extracted recipes to the user" refers to a function for the server to provide the extracted recipes to the user in an easy-to-view format.

[1693] "Means for displaying a link where the relevant ingredients and recipe can be purchased together" refers to a function that displays a link where the user can simultaneously purchase the recipe provided by the system and the ingredients related to it.

[1694] The "means for accepting user ratings" refers to a function that allows a user to input a rating for a recipe that they have tried.

[1695] "Means for updating the generative AI model" refers to the function of adjusting the AI ​​model based on user evaluation data and reflecting this in the next recipe suggestion.

[1696] The "JSON format" is a lightweight data exchange format for exchanging user input conditions and data between applications.

[1697] The system for implementing this invention consists primarily of a user, a terminal, and a server. The user specifies input conditions using the terminal, and the server generates and presents recipes based on those conditions. The system also improves by updating the generative AI model based on user evaluations.

[1698] Program processing explanation

[1699] 1. User operations

[1700] Users open the application and input criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal for under 500 yen," and "I want pumpkin as a seasonal ingredient in autumn." This input is based on the user's preferences and specific constraints.

[1701] 2. Submitting the conditions

[1702] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, ensuring secure data transmission.

[1703] 3. Recipe Generation

[1704] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[1705] 4. Presenting the recipe

[1706] The server extracts the relevant recipes from the database, converts the data into JSON format, and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto" is displayed, along with links to purchase the corresponding ingredients and recipes.

[1707] 5. Recipe Rating

[1708] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[1709] 6. Submitting and Reflecting Ratings

[1710] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[1711] Hardware / Software used

[1712] Device: Smartphone

[1713] Software: Commercially available browsers and dedicated applications

[1714] Server: Python, Flask (server side), SQL database

[1715] Examples of concrete examples and prompts

[1716] Examples:

[1717] The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal autumn ingredient." The device sends these criteria to the server. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the criteria and sends them to the device. The device displays the received recipes to the user, along with links to purchase related ingredients. The user makes "Pumpkin and spinach gratin" and rates it four stars. The device sends the rating data to the server, which adds the rating to a database and updates the generative AI model.

[1718] Example prompt sentence:

[1719] "Please suggest recipes based on specific ingredient conditions entered by the user. The conditions are: I don't like garlic, I have a wheat allergy, the cost is under 500 yen per meal, and pumpkin is a seasonal ingredient in autumn."

[1720] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1721] Step 1:

[1722] Users launch the smartphone application and input criteria such as specific ingredients, allergy information, budget, seasonal ingredients, etc. For example, users might input criteria such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn."

[1723] (Input) Condition data entered by the user

[1724] (Output) Prepare smartphone device for data transmission

[1725] Step 2:

[1726] The device converts the condition data entered by the user into JSON format and sends it to the server using the HTTPS protocol, ensuring data security during this process.

[1727] (Input) Condition data entered by the user (text format)

[1728] (Output) JSON format data sent to the server

[1729] Step 3:

[1730] The server parses the received JSON data and generates a database query based on the user-entered criteria, such as excluding specific ingredients (e.g., garlic, wheat), searching for recipes within the budget, and prioritizing recipes that use seasonal ingredients (e.g., pumpkin).

[1731] (Input) Condition data in JSON format received by the server

[1732] (Output) Generated SQL query

[1733] Step 4:

[1734] The server uses the generated SQL query to extract the corresponding recipes from the database. The extracted recipe information includes details such as the recipe name, ingredients, and cooking instructions.

[1735] (Input) Generated SQL query

[1736] (Output) Recipe information extracted from the database

[1737] Step 5:

[1738] The server converts the extracted recipe into JSON format and sends it to the terminal using the HTTPS protocol.

[1739] (Input) Recipe information extracted from the database

[1740] (Output) JSON format recipe data sent to the device

[1741] Step 6:

[1742] The device parses the JSON-formatted recipe data received from the server and displays it in a user interface, including the recipe name, ingredient list, detailed instructions, and links to purchase the associated ingredients and recipe.

[1743] (Input) JSON format recipe data received from the server

[1744] (Output) Recipe information and purchase link displayed in the user interface

[1745] Step 7:

[1746] Users try the displayed recipes and provide a rating within the application, including a star rating (e.g., 4 out of 5 stars) and detailed comments.

[1747] (Input) User rating data (star ratings and comments)

[1748] (Output) Prepare smartphone device for data transmission

[1749] Step 8:

[1750] The terminal converts the evaluation data entered by the user into JSON format and sends it to the server again using the HTTPS protocol.

[1751] (Input) User evaluation data (text format)

[1752] (Output) JSON formatted rating data sent to the server

[1753] Step 9:

[1754] The server analyzes the received evaluation data and adds the corresponding recipe evaluation information to the database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected in the next recipe generation.

[1755] (Input) JSON formatted rating data received by the server

[1756] (Output) Evaluation information and updated generative AI model added to the database

[1757] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1758] The system of the present invention has as its main components the user, a terminal, a server, and an emotion engine, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients and their emotional state, and updating the generative AI model based on the user's evaluation of these recipes.

[1759] System Overview

[1760] User operations

[1761] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, the user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn." At the same time, data (images, voice, text, etc.) can be input at the same time for the emotion engine to analyze the user's emotions.

[1762] Sending Conditions and Emotion Data

[1763] The device converts the condition data and emotion data entered by the user into JSON format and sends it to the server using the HTTPS protocol, thereby ensuring data security.

[1764] Recipe Generation

[1765] The server analyzes the received JSON data and generates a database query based on the conditions entered by the user. The emotion engine also analyzes the provided emotion data to understand the user's current emotional state. For example, if the user is feeling stressed, the generative AI model is adjusted to suggest recipes appropriate for that emotional state (such as recipes using ingredients with a relaxing effect). Specifically, the SQL query is generated as follows:

[1766] Exclude certain ingredients (e.g. garlic, wheat)

[1767] Within your budget (e.g., under 500 yen)

[1768] Prioritize seasonal ingredients (e.g. pumpkin)

[1769] Consider ingredients that correspond to your emotional state (e.g., ingredients that have a relaxing effect)

[1770] Recipe presentation

[1771] The server converts the extracted recipe data into JSON format and sends it to the device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto" is displayed. In addition, information related to the user's emotional state is also presented.

[1772] Recipe Rating

[1773] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[1774] Submitting and reviewing your evaluation

[1775] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected the next time a recipe is generated. The emotion engine also uses the user's evaluation data to improve the accuracy of its emotional state analysis.

[1776] Specific examples

[1777] For example:

[1778] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1779] 2. The user uses a facial recognition camera to input their current emotional state (e.g., feeling stressed).

[1780] 3. The device sends the condition data and emotion data to the server.

[1781] 4. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, and prioritizes recipes with a relaxing effect based on the analysis results of the emotion engine.

[1782] 5. The extracted recipe is sent to the terminal and displayed to the user.

[1783] 6. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[1784] 7. The device sends the evaluation data to the server.

[1785] 8. The server adds the rating to the database and updates the generative AI model and emotion engine.

[1786] In this way, the present invention is a system that suggests appropriate recipes according to the user's input conditions and emotional state.

[1787] The processing flow will be explained below.

[1788] Step 1:

[1789] The user opens the application and inputs criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. For example, they can input criteria such as "I don't like garlic," "I have a wheat allergy," "I want a meal that costs less than 500 yen," and "I want pumpkin as a seasonal ingredient in autumn."

[1790] Step 2:

[1791] Users input their current emotional state using an emotion-detecting camera and microphone. The emotion-detecting camera analyzes the user's facial expressions, and the microphone analyzes the user's vocal tone.

[1792] Step 3:

[1793] The device converts the condition data and emotion data entered by the user into JSON format. An example of the converted data is as follows:

[1794] json

[1795] {

[1796] "preferences": {

[1797] "garlic": "no",

[1798] "allergies": ["wheat"],

[1799] "budget": 500,

[1800] "season_ingredient": "pumpkin"

[1801] },

[1802] "emotion": {

[1803] "stress_level": "high",

[1804] "mood": "anxious"

[1805] }

[1806] }

[1807] Step 4:

[1808] The terminal sends the converted JSON data to the server using the HTTPS protocol, which ensures that the data arrives securely at the server.

[1809] Step 5:

[1810] The server parses the received JSON data, which is then broken down into fields based on the user's input (e.g., garlic, allergies, budget, season_ingredient) and emotional states (e.g., stress_level, mood).

[1811] Step 6:

[1812] The server generates a database query based on the parsed data to exclude certain ingredients. For example, the following SQL query is generated:

[1813] sql

[1814] SELECT FROM recipes

[1815] WHERE NOT (ingredients LIKE '%garlic%')

[1816] AND NOT (ingredients LIKE '%wheat%')

[1817] AND total_cost <= 500

[1818] AND ingredients LIKE '%pumpkin%'

[1819] ORDER BY total_rating DESC;

[1820] Step 7:

[1821] The server uses an emotion engine to evaluate the user's emotional state and prioritizes ingredients and recipes that have a relaxing effect. The emotion engine prioritizes recipes that contain ingredients that reduce stress (e.g., chamomile, lavender).

[1822] Step 8:

[1823] The server executes the generated query and extracts recipes from the database that match the criteria, such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto."

[1824] Step 9:

[1825] The server converts the extracted recipe data into JSON format, for example, the following JSON data is generated:

[1826] json

[1827] {

[1828] "recipes": [

[1829] {

[1830] "title": "Pumpkin and spinach gratin",

[1831] "ingredients": ["pumpkin", "spinach", ...],

[1832] "total_cost": 450,

[1833] "rating": 4.5,

[1834] "emotion_suitability": "high"

[1835] },

[1836] {

[1837] "title": "Pumpkin and mushroom risotto",

[1838] "ingredients": ["pumpkin", "mushroom", ...],

[1839] "total_cost": 480,

[1840] "rating": 4.7,

[1841] "emotion_suitability": "medium"

[1842] }

[1843] ]

[1844] }

[1845] Step 10:

[1846] The server sends the converted JSON data to the terminal.

[1847] Step 11:

[1848] The device parses the received JSON data and displays it in the user interface. For example, it displays recipe information such as "Pumpkin and Spinach Gratin" or "Pumpkin and Mushroom Risotto," as well as information related to the user's emotional state (e.g., "highly relaxing").

[1849] Step 12:

[1850] The user selects a dish from the presented recipes and actually cooks it. After cooking, the user rates the recipe in the application (e.g., 4 out of 5 stars) and enters detailed comments.

[1851] Step 13:

[1852] The device converts the rating data entered by the user into JSON format and sends it to the server. For example, the data is converted as follows:

[1853] json

[1854] {

[1855] "recipe_id": 12345,

[1856] "rating": 4,

[1857] "comment": "The pumpkin flavor was strong and delicious",

[1858] "emotion_feedback": {

[1859] "relaxation_effect": "high",

[1860] "mood_improvement": "significant"

[1861] }

[1862] }

[1863] Step 14:

[1864] The server analyzes the received evaluation data and adds the evaluation information of the corresponding recipe to the database.

[1865] Step 15:

[1866] The server updates the generative AI model and emotion engine based on the newly received evaluation data, allowing it to propose recipes that better match the user's emotional state and preferences the next time recipes are generated.

[1867] Example 2

[1868] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1869] In today's lifestyles, users often find it difficult to find suitable recipes that take into account ingredients, allergies, budgets, and seasonal ingredients. Taking the user's emotional state into account would also enable more satisfying recipe suggestions, but this has been difficult to achieve with conventional systems. Furthermore, the lack of a feedback function that reflects the user's evaluation of the recipe and improves the next suggestions means that user satisfaction does not improve over the long term.

[1870] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1871] In this invention, the server includes means for accepting user input conditions, means for transmitting the conditions to the server, means for generating a database query, means including an emotion engine for adjusting recipes based on the user's emotional state, means for extracting recipes from the database based on the conditions and the emotional state, means for presenting recipes to the user, means for accepting user ratings, and means for transmitting the ratings to the server and updating the generative AI model. This makes it possible to propose appropriate recipes based on the user's input conditions and emotional state, and realizes system improvements based on ratings.

[1872] A "user" is a person who uses this system to input ingredients and conditions, and makes recipe suggestions and evaluations.

[1873] "Input conditions" is information that allows the user to specify specific ingredients, allergy information, budget, seasonal ingredients, and the like.

[1874] The "server" is a central processing unit that processes the received information, generates database queries, extracts recipes, runs the emotion engine, and collects and processes rating data.

[1875] A "database query" is a query statement that the server generates to extract recipes that meet the user's requirements from the database.

[1876] The "Emotion Engine" is a system that analyzes the user's emotional state and suggests recipes that are appropriate for that state.

[1877] A "recipe" is a cooking instruction manual that includes information such as ingredients, steps, and cooking time.

[1878] "Evaluation" refers to the act of a user providing feedback on a presented recipe in the form of a star rating, a comment, or the like.

[1879] A "generative AI model" is an artificial intelligence model that suggests and adjusts recipes based on the data it receives.

[1880] The system of this invention has as its main components the user, a terminal, a server, and an emotion engine, and provides a mechanism for proposing, extracting, and displaying recipes based on the user's input conditions regarding specific ingredients and their emotional state, and for updating the generative AI model based on the user's evaluation of these recipes.

[1881] First, the user opens the application and inputs criteria such as a specific food ingredient (e.g., pumpkin), allergy information (e.g., garlic dislike, wheat allergy), budget (e.g., under 500 yen), and seasonal ingredients (e.g., pumpkin in autumn). The user also uses an input device such as a camera or microphone to input their current emotional state (e.g., feeling stressed). This information is captured by the application as text input, image, or voice data.

[1882] Next, the device converts the condition data and emotion data entered by the user into JSON format. This process is performed by the data conversion module. The converted data is sent to the server using the HTTPS protocol. Using the HTTPS protocol encrypts the data and maintains security.

[1883] The server analyzes the received JSON data and generates a database query based on the conditions entered by the user. The server's internal SQL query generation module generates an appropriate query based on the request. The emotion engine also analyzes the provided emotion data (e.g., image recognition, voice recognition) to understand the user's current emotional state. Based on this information, the generative AI model filters recipes that match the user's emotions.

[1884] For example, the following SQL query is generated: SELECT FROM recipe WHERE ingredients NOT IN ('garlic', 'wheat') AND budget <= 500 AND season = 'autumn'. The emotion engine analyzes the emotion data and determines the user's emotional state (e.g., "high stress").

[1885] The server then converts the extracted recipe data into JSON format and sends it to the device. The device parses the received JSON data and displays the recipe information on the user interface. The user can view a list of suggested recipes, including recipes such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto." Information related to the user's emotional state is also displayed.

[1886] The user tries the presented recipe and enters their rating in the application, for example, by entering a star rating (e.g., 4 stars) or a detailed comment (e.g., "It was delicious, but a little salty"). The device converts the user-entered rating data into JSON format and sends it to the server.

[1887] The server analyzes the received rating data and adds the rating information for the corresponding recipe to a database. The generative AI model is adjusted based on this rating data and reflected in the next recipe generation. The emotion engine also uses user rating data to improve the accuracy of emotional state analysis.

[1888] Here are some examples of prompts:

[1889] 1. "Please suggest recipes that use specific ingredients (e.g., pumpkin, spinach). Also, please take into consideration allergy information (e.g., wheat allergy), budget (e.g., under 500 yen), and seasonal ingredients, and prioritize recipes that have a relaxing effect."

[1890] 2. "The user is feeling stressed. Please suggest some recipes that will help them relax."

[1891] In this way, the present invention is a system that proposes appropriate recipes based on the user's input conditions and emotional state, and repeats the process of improving the system based on evaluations.

[1892] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1893] Step 1:

[1894] The user launches the application and inputs criteria such as ingredients, allergy information, budget, and seasonal ingredients. For example, they can input information such as "I don't like garlic," "I have a wheat allergy," "A meal costs less than 500 yen," and "Pumpkin is a seasonal ingredient in autumn." The user also uses a camera or microphone to input their emotional state. The input data is then imported into the application as text, images, and audio data.

[1895] Step 2:

[1896] The device converts the condition data and emotion data entered by the user into JSON format. The converted data (input: user's condition data and emotion data, output: JSON format data) is then sent to the server using the HTTPS protocol. This ensures that the data is encrypted before transmission, ensuring security.

[1897] Step 3:

[1898] The server parses the received JSON data. First, the data parser breaks the JSON data into individual elements and extracts the conditions entered by the user (input: JSON data, output: parsed condition data). Next, the database query generation module generates an SQL query based on the condition data (e.g., "SELECT FROM recipe WHERE ingredients NOT IN ('garlic', 'wheat') AND budget <= 500 AND season = 'Autumn'"). Finally, the emotion engine parses the emotion data and determines the user's emotional state.

[1899] Step 4:

[1900] The emotion engine interprets the user's emotional state based on the provided emotion data and reflects the result (e.g., "high stress") in the extracted recipes. Specifically, the emotion engine adjusts the generative AI model to prioritize recipes containing ingredients that are good for stress (input: analyzed emotion data, output: adjusted recipe query).

[1901] Step 5:

[1902] The server converts the recipe data extracted from the database into JSON format and sends it to the device (input: extracted recipe data, output: recipe data converted into JSON format). By doing this, the server makes it easier for the device to analyze the data it receives.

[1903] Step 6:

[1904] The device analyzes the received JSON data and displays the recipe information on the user interface. Specifically, the device breaks down the JSON data into recipe names, ingredients, cooking procedures, etc., and provides them to the user in a visually easy-to-understand format (input: recipe data in JSON format, output: recipe information displayed on the interface).

[1905] Step 7:

[1906] The user tries the presented recipe and inputs their rating into the application, for example, by giving a star rating (e.g., four stars) or a comment (e.g., "It was delicious, but a little salty") (Input: Thoughts and rating on the recipe, Output: Rating data).

[1907] Step 8:

[1908] The device converts the evaluation data received from the user into JSON format and sends it to the server (input: evaluation data, output: JSON-formatted evaluation data). The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. The generative AI model is also adjusted based on this evaluation data, and this is reflected the next time a recipe is generated (input: JSON-formatted evaluation data, output: updated generative AI model).

[1909] (Application example 2)

[1910] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1911] Conventional recipe suggestion systems only suggest recipes based on the user's input of ingredients, but do not consider the user's emotional state, failing to address the emotional needs of users. Furthermore, they lack an interface for inputting ingredients and emotional state in a physical store. As a result, users lack a way to obtain optimal recipes in stressful situations, reducing the overall convenience and satisfaction of the system.

[1912] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1913] In this invention, the server includes means for accepting input conditions for specific ingredients from a user, means for transmitting the accepted conditions to the server, means for extracting recipes from a database based on the conditions, means for presenting the extracted recipes to the user, means for accepting a user rating, means for transmitting the accepted rating to the server and updating the generative AI model, means for recognizing the user's emotional state, and means for adjusting the recipe based on the emotional state, thereby enabling the server to propose recipes optimized for the user's emotional state and ingredient conditions.

[1914] "User" refers to any individual or entity that uses the System.

[1915] "Specific ingredients" refers to one or more ingredients designated by the user.

[1916] "Input conditions" are conditions that the user specifies to the system, and include specific ingredients, allergy information, budget, seasonal ingredients, and the like.

[1917] "Server" refers to a computer system that processes data received from users and generates recipes in conjunction with a database.

[1918] "Database" refers to a collection of information that stores recipe information.

[1919] "Emotion engine" refers to a software module for recognizing and analyzing a user's emotional state.

[1920] A "recipe" refers to information that includes steps and ingredients needed to prepare a dish.

[1921] "Generative AI model" refers to a recipe model that is generated based on data obtained from the user.

[1922] "Facial recognition technology" refers to technology that uses a camera to identify a user's face and analyze their emotional state.

[1923] The "in-store mode" is a mode intended for use in a physical store, and includes a function that shows where to obtain the selected ingredients.

[1924] "Rating" refers to the feedback a user gives to a suggested recipe.

[1925] "JSON format" stands for JavaScript Object Notation, a lightweight data exchange format.

[1926] The present invention is a system that suggests recipes based on input conditions and emotional state of a user regarding specific ingredients, and is configured as follows.

[1927] 1. User Operation

[1928] Using a smartphone application, users input criteria such as specific ingredients, allergy information, budget, and seasonal ingredients. Using facial recognition technology, users can also input their emotional state at the same time. For example, a user can input criteria such as "I don't like garlic," "I have a wheat allergy," "It's under 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1929] 2. Data transmission

[1930] The user's device converts the received condition data and emotion data into JSON format and sends it to the server using the HTTPS protocol, thereby maintaining data security.

[1931] 3. Recipe Generation

[1932] The server parses the received JSON data and generates a database query based on the conditions entered by the user. The emotion engine also analyzes the provided emotion data to understand the user's current emotional state. For example, if the user is feeling stressed, the generative AI model is adjusted to suggest recipes appropriate for that emotional state (such as recipes using ingredients with a relaxing effect). The SQL query is generated as follows:

[1933] Exclude certain ingredients (e.g. garlic, wheat)

[1934] Within your budget (e.g., under 500 yen)

[1935] Prioritize seasonal ingredients (e.g. pumpkin)

[1936] Consider ingredients that correspond to your emotional state (e.g., ingredients that have a relaxing effect)

[1937] 4. Presenting the recipe

[1938] The server converts the extracted recipe data into JSON format and sends it to the user's device. The device then analyzes the received recipe data and displays it on the user interface. For example, recipe information such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto" is displayed. In addition, information related to the user's emotional state is also presented.

[1939] 5. Recipe Rating

[1940] Users try the recipes presented to them and then rate them in the application, either by rating them as a star (e.g., 4 out of 5 stars) or by providing detailed comments.

[1941] 6. Sending and Reflecting Evaluation Data

[1942] The device converts the evaluation data entered by the user into JSON format and sends it to the server. The server analyzes the received evaluation data and adds the evaluation information for the corresponding recipe to a database. Furthermore, the generative AI model is adjusted based on this evaluation data and reflected the next time a recipe is generated. The emotion engine also uses the user's evaluation data to improve the accuracy of its emotional state analysis.

[1943] Hardware and software used

[1944] Hardware: Smartphone (with built-in camera)

[1945] Software: Smartphone application, OpenCV, EmotionRecognizer, server (including database), HTTPS protocol, generative AI model, emotion engine

[1946] Specific examples of possible uses include:

[1947] 1. The user opens the application and enters the following criteria: "I don't like garlic," "I have a wheat allergy," "It costs less than 500 yen per meal," and "Pumpkin is a seasonal ingredient in autumn."

[1948] 2. The user uses a facial recognition camera to input their current emotional state (e.g., feeling stressed).

[1949] 3. The device sends the condition data and emotion data to the server.

[1950] 4. The server extracts recipes such as "Pumpkin and spinach gratin" and "Pumpkin and mushroom risotto" based on the conditions, and prioritizes recipes with a relaxing effect based on the analysis results of the emotion engine.

[1951] 5. The extracted recipe is sent to the terminal and displayed to the user.

[1952] 6. A user makes "Pumpkin and Spinach Gratin" and rates it 4 stars.

[1953] 7. The device sends the evaluation data to the server.

[1954] 8. The server adds the rating to the database and updates the generative AI model and emotion engine.

[1955] Example prompt sentence:

[1956] Please suggest a recipe that meets the following criteria:

[1957] Ingredients: Pumpkin, spinach

[1958] Allergies: Wheat allergy

[1959] Budget: 500 yen

[1960] Emotional state: Stressed

[1961] Season: Autumn seasonal ingredients

[1962] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1963] Step 1:

[1964] The user starts the smartphone application and selects "physical store mode." Next, they input the ingredients they want to purchase (e.g., pumpkin and spinach). The input ingredient data is temporarily saved in the application.

[1965] Step 2:

[1966] The user inputs their emotional state using facial recognition technology. By activating the camera and capturing their face, the EmotionRecognizer module analyzes their emotions. The analyzed emotional data (e.g., feeling stressed) is generated. This emotional data is temporarily stored along with the food ingredient data.

[1967] Step 3:

[1968] The terminal compiles the information entered by the user, such as ingredient information, emotional data, allergy information, budget, and seasonal ingredients, and converts it into JSON format. The converted data is sent to the server using the HTTPS protocol. The input is the user data, and the output is the JSON data sent to the server.

[1969] Step 4:

[1970] The server parses the received JSON data. It generates a database query based on the input criteria and extracts matching recipes from the recipe database. Specifically, the following filtering is applied: exclude specific ingredients, stay within budget, prioritize seasonal ingredients, and consider ingredients according to emotional state. The input is JSON data, and the output is the filtered recipe data.

[1971] Step 5:

[1972] The server's emotion engine adjusts the generative AI model based on the analyzed emotion data to prioritize recipes that suit the user's emotional state. The generative AI model is configured to recommend recipes that use ingredients with a relaxing effect, for example. The input is emotion data, and the output is adjusted recipe data.

[1973] Step 6:

[1974] The server converts the extracted and adjusted recipe data into JSON format and sends it to the terminal. The terminal parses the received JSON data and displays the recipe information on the user interface. Specifically, it displays recipes such as "Pumpkin and Spinach Gratin" and "Pumpkin and Mushroom Risotto." The input is the recipe data, and the output is the displayed recipe information.

[1975] Step 7:

[1976] Users try the displayed recipes and enter a rating (e.g., four stars) and comments in the application. This rating data is temporarily stored on the device.

[1977] Step 8:

[1978] The device converts the evaluation data entered by the user into JSON format and sends it to the server using the HTTPS protocol. The server analyzes the received evaluation data and adds it to a database as evaluation information for the corresponding recipe. Furthermore, the generative AI model is adjusted using this evaluation data and reflected the next time a recipe is generated. The input is the evaluation data, and the output is the adjusted generative AI model.

[1979] Example prompt sentence:

[1980] Please suggest a recipe that meets the following criteria:

[1981] Ingredients: Pumpkin, spinach

[1982] Allergies: Wheat allergy

[1983] Budget: 500 yen

[1984] Emotional state: Stressed

[1985] Season: Autumn seasonal ingredients

[1986] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

[1987] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1988] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1989] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1990] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1991] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1992] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1993] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1994] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1995] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1996] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1997] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1998] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1999] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[2000] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[2001] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[2002] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[2003] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[2004] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[2005] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[2006] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[2007] The following is further disclosed regarding the above embodiment.

[2008] (Claim 1)

[2009] A means for accepting input conditions regarding specific ingredients from a user;

[2010] means for transmitting the accepted conditions to a server;

[2011] means for extracting recipes from a database based on criteria;

[2012] means for presenting the extracted recipe to a user;

[2013] means for accepting user ratings;

[2014] A means for transmitting the received evaluation to a server and updating the generative AI model;

[2015] A system including:

[2016] (Claim 2)

[2017] The system of claim 1, wherein recipes that meet the conditions are sent in JSON format.

[2018] (Claim 3)

[2019] The system according to claim 1, wherein recipes are extracted taking into consideration the seasonality of ingredients and budget information.

[2020] "Example 1"

[2021] (Claim 1)

[2022] A means for accepting input conditions regarding specific ingredients from a user;

[2023] means for transmitting the accepted conditions to the digital device;

[2024] means for extracting information from a data store based on a condition;

[2025] means for presenting the extracted information to a user;

[2026] means for accepting user ratings;

[2027] means for transmitting the received evaluation to the digital device to update the generative artificial intelligence model;

[2028] means for transmitting the extracted information using a secure communications protocol;

[2029] A system including:

[2030] (Claim 2)

[2031] 2. The system of claim 1, wherein the information that meets the conditions is transmitted in a data exchange format.

[2032] (Claim 3)

[2033] 10. The system of claim 1, wherein the information is extracted taking into account seasonality and cost information of ingredients.

[2034] "Application Example 1"

[2035] (Claim 1)

[2036] A means for accepting input conditions regarding specific ingredients from a user;

[2037] means for transmitting the accepted conditions to a server;

[2038] means for extracting recipes from a database based on criteria;

[2039] A means for presenting the extracted recipe to the user and displaying a link where the corresponding ingredients and the recipe can be purchased together;

[2040] means for accepting user ratings;

[2041] A means for transmitting the received evaluation to a server and updating the generative AI model;

[2042] A system including:

[2043] (Claim 2)

[2044] The system of claim 1, wherein recipes that meet the conditions are sent in JSON format.

[2045] (Claim 3)

[2046] The system according to claim 1, wherein recipes are extracted taking into consideration the seasonality and budget information of ingredients, and links to purchase related ingredients are displayed.

[2047] "Example 2: Combining Emotion Engines"

[2048] (Claim 1)

[2049] A means for accepting input conditions regarding specific ingredients from a user;

[2050] means for transmitting the accepted conditions to a server;

[2051] means for generating a database query based on the condition;

[2052] means including an emotion engine that adjusts recipes based on the emotional state of a user;

[2053] means for extracting recipes from a database based on conditions and emotional state;

[2054] means for presenting the extracted recipe to a user;

[2055] means for accepting user ratings;

[2056] A means for transmitting the received evaluation to a server and updating the generative AI model;

[2057] A system including:

[2058] (Claim 2)

[2059] The system of claim 1, wherein recipes that meet the conditions are sent in JSON format.

[2060] (Claim 3)

[2061] The system according to claim 1, wherein recipes are extracted taking into consideration the seasonality of ingredients and budget information.

[2062] "Application example 2 when combining emotion engines"

[2063] (Claim 1)

[2064] A means for accepting input conditions regarding specific ingredients from a user;

[2065] means for transmitting the accepted conditions to a server;

[2066] means for extracting recipes from a database based on criteria;

[2067] means for presenting the extracted recipe to a user;

[2068] means for accepting user ratings;

[2069] A means for transmitting the received evaluation to a server and updating the generative AI model;

[2070] means for recognizing the emotional state of a user;

[2071] a means for adjusting recipes based on emotional state;

[2072] A system including:

[2073] (Claim 2)

[2074] The system of claim 1, wherein recipes that meet the conditions are sent in JSON format.

[2075] (Claim 3)

[2076] The system according to claim 1, wherein recipes are extracted taking into consideration the seasonality of ingredients and budget information.

[2077] (Claim 4)

[2078] The system of claim 1, having a mode for use in a physical store, and presenting the location of a selected ingredient.

[2079] (Claim 5)

[2080] 10. The system of claim 1, wherein facial recognition technology is used to input the user's emotional state. [Explanation of symbols]

[2081] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for accepting input conditions regarding specific ingredients from a user; means for transmitting the accepted conditions to a server; means for extracting recipes from a database based on criteria; means for presenting the extracted recipe to a user; means for accepting user ratings; A means for transmitting the received evaluation to a server and updating the generative AI model; A system including:

2. The system according to claim 1, wherein recipes that meet the conditions are transmitted in JSON format.

3. The system according to claim 1, wherein recipes are extracted taking into consideration the seasonality of ingredients and budget information.

Images