System

Abstract

A system is provided.SOLUTION: A system comprising: means for receiving preference information and dietary restriction information from a user; means for filtering matching recipes based on the preference information and dietary restriction information; means for randomly selecting a recipe from among the filtered recipes; and means for providing the selected recipe to the user.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] For many people who enjoy cooking, finding new recipes or recipes that fit their preferences or dietary restrictions can be difficult. Finding recipes that accommodate limited ingredients or specific dietary restrictions can also be a time-consuming and labor-intensive challenge. Furthermore, few existing online platforms offer personalized recipes, making it difficult to increase user satisfaction. There is a need for a system that solves these problems and makes cooking a more enjoyable, accessible, and creative experience. [Means for solving the problem]

[0005] To solve the above problems, the present invention provides the following means: A system including: means for receiving preference information and dietary restriction information from a user; means for filtering suitable recipes based on the preference information and dietary restriction information; means for randomly selecting a recipe from the filtered recipes; and means for providing the selected recipe to the user. The system further includes means for receiving ingredient information from the user and filtering recipes taking the ingredient information into consideration, and means operated on a subscription basis, allowing users to periodically receive personalized recipes.

[0006] "User" refers to an individual or organization that uses the system to request the creation of a recipe.

[0007] "Preference information" refers to information that indicates a user's preferences for specific types of cuisine or eating styles.

[0008] "Dietary restriction information" refers to information that indicates that a user should avoid certain ingredients or dishes.

[0009] A "recipe" refers to information that shows the steps and ingredients needed to make a dish.

[0010] "Filtering" refers to the process of sorting data based on specific conditions or criteria and removing unnecessary data.

[0011] "Randomly selected" means to choose randomly without following any particular rules.

[0012] "Provide" means to deliver or make available information or services to a user.

[0013] "Ingredient information" refers to information about specific foods and ingredients that the user owns.

[0014] "Subscription-based" refers to a model in which a service or product can be used on an ongoing basis by paying a periodic fee.

[0015] "System" refers to a set of hardware, software, and procedures that work together to achieve a specific purpose. [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 present invention relates to an online recipe creation system that enhances users' dining experiences. The system receives user preference information and dietary restriction information, and generates and serves appropriate recipes based on the information. It also allows filtering based on certain ingredient information and operates on a subscription basis.

[0038] A natural language description of the program's operation

[0039] User

[0040] First, users input their preferences (e.g., "Italian food," "low carbohydrates") and dietary restrictions (e.g., "gluten-free") into the system. Then, they log in and request a recipe. Users can also input specific ingredients they have on hand.

[0041] Terminal

[0042] The terminal (user's device) provides an interface for sending the user's input preference information, dietary restriction information, and ingredient information to the server. When the user presses the recipe generation button, the terminal sends this information to the server in JSON format.

[0043] server

[0044] The server receives the user information sent from the terminal and performs the following process.

[0045] 1. Extract user information:

[0046] The server extracts the user ID, preference information, dietary restriction information, and ingredient information from the received data.

[0047] 2. Filtering recipes:

[0048] The server filters all recipes in the database based on the user's preferences and dietary restrictions. For example, if a user selects "Italian" and "low carb" and specifies "gluten free" as a dietary restriction, only recipes that meet these criteria will be filtered.

[0049] 3. Considering ingredient information:

[0050] The server also takes into account the ingredient information entered by the user and performs further filtering. For example, if a user enters that they have "tomatoes" and "chicken," recipes containing these ingredients will be prioritized.

[0051] 4. Random recipe selection:

[0052] From the filtered recipes, the server randomly selects one recipe.

[0053] 5. Recipe provided:

[0054] The server returns the selected recipe to the terminal in JSON format.

[0055] Specific examples

[0056] For example, if user "user1" enters the following information:

[0057] Preferences: "Italian food" and "low carbohydrates"

[0058] Dietary Information: "Gluten Free"

[0059] Ingredients: "Tomato" "Chicken"

[0060] When the user presses the recipe generation button, the device sends this information to the server, which considers the user's preferences, dietary restrictions, and available ingredients to select an appropriate recipe, such as "Chicken Alfredo." The server then returns the recipe to the device, which displays it to the user.

[0061] This allows users to easily find suitable recipes based on their preferences, dietary restrictions, and available ingredients, allowing them to enjoy cooking. The system provides users with new cooking ideas and helps expand the variety of their meals.

[0062] The processing flow will be explained below.

[0063] Step 1:

[0064] The user logs into the platform and presses the recipe creation button.

[0065] Step 2:

[0066] The terminal displays an interface for inputting the user's preference information, dietary restriction information, and ingredient information.

[0067] Step 3:

[0068] The user inputs preference information (e.g., "Italian food," "low carbohydrate"), dietary restriction information (e.g., "gluten-free"), and ingredient information (e.g., "tomato," "chicken").

[0069] Step 4:

[0070] The device receives user input, converts it to JSON format, and sends it to the server.

[0071] Step 5:

[0072] The server processes the request received from the terminal and extracts the user ID, preference information, dietary restriction information, and ingredient information.

[0073] Step 6:

[0074] The server filters all recipes in the database based on the preference and dietary restriction information, selecting recipes that match the user's specified preferences and do not violate any dietary restrictions.

[0075] Step 7:

[0076] The server further filters the recipes based on the user's ingredient information, giving priority to recipes that include ingredients that the user owns.

[0077] Step 8:

[0078] The server randomly selects one recipe from the filtered list.

[0079] Step 9:

[0080] The server returns the selected recipe to the device in JSON format.

[0081] Step 10:

[0082] The terminal analyzes the recipe information received from the server and displays it on the user interface.

[0083] Step 11:

[0084] The user checks the presented recipe and enjoys cooking.

[0085] Example 1

[0086] 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."

[0087] Conventional recipe search systems have difficulty in considering detailed user preferences, dietary restrictions, and ingredients available on hand, making it difficult for users to quickly obtain the information they need. Furthermore, they do not adequately provide recipes that meet the individual needs of users, making it difficult to improve the variety and satisfaction of meals.

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

[0089] In this invention, the server includes means for receiving preference information and dietary restriction information from a user, means for filtering suitable recipes based on the preference information and dietary restriction information, means for receiving ingredient information from the user, means for filtering recipes taking the ingredient information into consideration, means for randomly selecting a recipe from the filtered recipes, means for providing the selected recipe to the user, means for the user to log in and transmit authentication information to the server, and means operated on a subscription basis for the user to periodically receive personalized recipes. This allows users to quickly obtain recipes based on their detailed preferences and restrictions, thereby improving the variety and satisfaction of their meals.

[0090] "User" refers to a person who uses the system and inputs information such as their preferences, dietary restrictions, and ingredients.

[0091] "Preference information" refers to information that serves as the basis for selecting a particular recipe, such as the user's type of cuisine and nutritional restrictions.

[0092] "Dietary restriction information" refers to information about a user's allergies or nutritional restrictions, such as information to avoid certain foods or ingredients.

[0093] "Ingredient information" refers to information about specific ingredients that the user already owns, and is taken into consideration when selecting a recipe.

[0094] "Filtering" refers to the process of sorting data based on specific conditions and extracting only the relevant items.

[0095] "Randomly select" means to randomly select one of the filtered items.

[0096] "Server" refers to a central computer system that processes information received from users and provides the necessary data.

[0097] A "terminal" is a device that allows a user to access a system and is responsible for input and display.

[0098] "Authentication information" is information used to verify a user's identity, and typically consists of a user ID and password.

[0099] "Subscription-based" refers to a method of using a service by paying a recurring fee, which allows users to receive personalized content on a regular basis.

[0100] "JSON format" is an abbreviation for JavaScript Object Notation, and refers to a lightweight data exchange format for describing data in a structured text format.

[0101] The present invention relates to an online recipe generation system that enhances a user's dining experience. The system receives a user's preference information and dietary restriction information, and generates and serves appropriate recipes based on that information. It can also provide more personalized recipes by taking into account specific ingredient information the user has.

[0102] User

[0103] First, a user enters their preferences (e.g., "Italian food," "low carbohydrates," etc.) and dietary restrictions (e.g., "gluten-free") into the system. Next, they log in to their account and request recipe generation. The user can also enter specific ingredient information (e.g., "tomato," "chicken," etc.) that they have on hand. This information is sent to the server via their terminal.

[0104] Terminal

[0105] The terminal (user's device) converts the user's input preferences, dietary restrictions, and ingredient information into JSON format and sends it to the server. The terminal also sends the user's login authentication information to the server. The filtered recipe is sent back to the terminal and displayed to the user.

[0106] server

[0107] When the server receives the user information sent from the device, it analyzes the JSON-formatted data and extracts preference information, dietary restriction information, and ingredient information. Based on this information, the server filters all recipes in the database. It then further filters the recipes taking into account ingredient information. From the recipes obtained as a result of the filtering, the server randomly selects one recipe and returns it to the device in JSON format.

[0108] Specific examples

[0109] For example, if user "user1" enters the following information:

[0110] Preferences: "Italian food" and "low carbohydrates"

[0111] Dietary Information: "Gluten Free"

[0112] Ingredients: "Tomato" "Chicken"

[0113] When the user presses the recipe generation button, the device sends this information to the server, which considers the user's preferences, dietary restrictions, and available ingredients to select an appropriate recipe, such as "Chicken Alfredo." The server then returns the recipe to the device, which displays it to the user.

[0114] Example prompt sentence:

[0115] Can you recommend some "Italian" and "low carb" recipes that are "gluten free" and contain "tomatoes" and "chicken"?

[0116] In this way, users can quickly obtain optimal recipes based on their own preferences and restrictions using ingredients they have on hand. This system provides users with new cooking ideas and improves the variety and satisfaction of their meals.

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

[0118] Step 1: The user logs into the system.

[0119] Input: User ID and password

[0120] Output: Authentication token

[0121] Specific operation: The user enters their user ID and password on the login screen and sends them to the terminal. The terminal then sends that information to the server. The server verifies the received information, and if the user is legitimate, generates an authentication token and sends it back to the terminal.

[0122] Step 2: The user inputs preference information, dietary restriction information, and ingredient information.

[0123] Input: Preference information (e.g., "Italian food" or "low carb"), dietary restriction information (e.g., "gluten-free"), ingredient information (e.g., "tomato" or "chicken")

[0124] Output: Request data in JSON format

[0125] Specific operation: The user inputs various information using a dedicated input interface, and the device converts this information into JSON format.

[0126] Step 3: The terminal transmits the user's input information to the server.

[0127] Input: Request data in JSON format

[0128] Output: Send data to the server

[0129] Specific operation: The device sends the user's preference information, dietary restriction information, and ingredient information in JSON format to the server. The sent data, including user authentication, is packetized and sent to the server.

[0130] Step 4: The server parses and extracts the user information.

[0131] Input: Request data in JSON format

[0132] Output: User, preferences, dietary restrictions, and ingredient information

[0133] Specific operation: The server parses the received JSON data and extracts the user ID, preference information, dietary restriction information, and ingredient information. This data is temporarily stored in the server's memory.

[0134] Step 5: The server filters the recipes based on the preference information and dietary restriction information.

[0135] Input: Preferences and dietary restrictions

[0136] Output: Filtered recipe list

[0137] What happens: The server filters all recipes in the database to find those that match the user's preferences and dietary restrictions. For example, it selects only "Italian," "low carb," and "gluten-free" recipes.

[0138] Step 6: The server further filters the recipes taking into account the ingredient information.

[0139] Input: filtered recipe list, ingredient information

[0140] Output: A list of recipes filtered by ingredients.

[0141] Specific operation: The server further filters the recipe list obtained from the first filtering, taking into account the ingredient information possessed by the user, and extracts only recipes that contain the relevant ingredients. For example, it extracts only recipes that contain "tomato" and "chicken."

[0142] Step 7: The server randomly selects a recipe from the filtered recipes.

[0143] Input: A list of recipes filtered by ingredients

[0144] Output: Selected recipes

[0145] Specific operation: The server randomly selects one recipe from the list of recipes obtained by the above filtering. This selection process is performed randomly using a random number generator or the like.

[0146] Step 8: The server returns the selected recipe to the terminal in JSON format.

[0147] Input: Selected recipe

[0148] Output: Recipe data in JSON format

[0149] What it does: The server converts a randomly selected recipe into JSON format and sends it to the device. The device receives the data and returns a confirmation to the server that it was received successfully.

[0150] Step 9: The terminal displays the received recipe to the user.

[0151] Input: Recipe data in JSON format

[0152] Output: The recipe displayed in the user interface

[0153] Specific operation: The device parses the received JSON data and extracts the recipe information. The extracted recipe information is displayed on the screen in a format that the user can view. This allows the user to view recipes based on their preferences and restrictions.

[0154] (Application example 1)

[0155] 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."

[0156] In conventional food delivery services, it is difficult for users to select appropriate dishes based on their preferences and dietary restrictions. In addition, due to the lack of a system to quickly find suitable recipes and dishes, users have to spend time searching for dishes that suit them. This makes it particularly difficult for users with specific dietary restrictions or preferences to choose a satisfying meal.

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

[0158] In this invention, the server includes means for receiving preference information and dietary restriction information from a user, means for filtering suitable dishes based on the preference information and dietary restriction information, means for suggesting appropriate dishes from among the filtered dishes, and means for providing the suggested dishes to the user and ordering the appropriate dishes, thereby enabling the user to easily select and quickly order the optimal dishes based on their preferences and dietary restrictions.

[0159] "User preference information" refers to information such as the type of food, seasoning, cooking method, etc. that the user prefers.

[0160] "Dietary restriction information" refers to information about ingredients or foods that a user should avoid, such as restrictions due to allergies, health conditions, or religious reasons.

[0161] "Filtering" refers to the process of narrowing down items in a database based on specific criteria.

[0162] "Means for suggesting appropriate dishes" refers to a function within the system for selecting and suggesting optimal dishes based on the user's preference information and dietary restriction information.

[0163] "Means for ordering food" refers to a function within the system for executing the process of ordering the food selected by the user from a food service provider.

[0164] The present invention relates to a system that suggests optimal dishes based on a user's preference information and dietary restriction information, and enables the user to order through a food delivery service.

[0165] To implement the invention, the following configurations and processes are included.

[0166] User

[0167] A user uses a smartphone app to input their preferences (e.g., Italian food, low carb, etc.) and dietary restrictions (e.g., gluten-free). This information is entered through the app's interface. Once the user confirms their order, this information is sent to the server through the app's interface. As a concrete example, suppose the user inputs "Italian food," "low carb," and "gluten-free."

[0168] Terminal

[0169] The terminal provides an interface for sending the user's preference information and dietary restriction information to the server. This interface has a mechanism for sending data to the server in JSON format, for example. When the user presses the order confirmation button, the terminal sends this information to the server.

[0170] server

[0171] The server processes the received user information and proposes the most suitable dish. Specifically, it performs the following process.

[0172] 1. Extract user information:

[0173] The server extracts the user ID, preference information, and dietary restriction information from the received data.

[0174] 2. Cuisine filtering:

[0175] The server filters all dishes in the food delivery service's database based on the user's preferences and dietary restrictions. For example, if the user selects "Italian," "low carb," and "gluten-free," only dishes that meet these criteria will be filtered.

[0176] 3. Food suggestions:

[0177] From the filtered dishes, the server suggests appropriate dishes and returns them to the terminal in JSON format.

[0178] 4. Manage your orders:

[0179] Once the user selects a suggested dish and confirms the order, the information is sent to the restaurant, and once the food is ready, the user is notified of delivery information.

[0180] Hardware and software used

[0181] The hardware used includes a standard smartphone and server. The software includes a smartphone application and a back-end system that implements a server-side recipe filtering algorithm. It also includes a part that calls a food delivery API to retrieve and select dish information.

[0182] Specific examples

[0183] For example, if user "user1" enters the following information:

[0184] Preferences: "Italian food" and "low carbohydrates"

[0185] Dietary Information: "Gluten Free"

[0186] When the user presses the order confirmation button, the device sends this information to the server. The server considers the user's preferences and dietary restrictions, suggests appropriate dishes, and sends them back to the device. Once the user selects the most suitable dish, they can confirm the order and the food will be delivered from the restaurant.

[0187] Prompt Sentence Examples

[0188] A user has entered their preferences (Italian, low carb) and dietary restrictions (gluten free). Using this information, use a food delivery API to suggest a list of dishes that would best suit the user.

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

[0190] Step 1:

[0191] Users use a smartphone app to input their preferences (e.g., Italian food, low carbohydrates, etc.) and dietary restrictions (e.g., gluten-free). This information is prepared as JSON-formatted data in the app's interface. Input: User preferences and dietary restrictions. Output: User information in JSON format.

[0192] Step 2:

[0193] The device sends the preference information and dietary restriction information entered by the user to the server. Specifically, when the user presses the order confirmation button, the device sends this information to the server via the in-app API. Input: User information in JSON format. Output: Information sent to the server.

[0194] Step 3:

[0195] The server processes the data received from the device and extracts the user ID, preference information, and dietary restriction information. Specifically, the server parses the received JSON data and stores the necessary information in variables. Input: User information in JSON format. Output: Extracted user information.

[0196] Step 4:

[0197] The server filters all dishes in the database based on the user's preferences and dietary restrictions. Specifically, it uses SQL queries to extract only the dishes that match the preferences and restrictions and stores them in a temporary database. Input: Extracted user information. Output: Filtered list of dishes.

[0198] Step 5:

[0199] The server then suggests appropriate dishes from the filtered list. Specifically, it sorts the filtered list of dishes using an algorithm and selects the most suitable dish. Input: Filtered list of dishes. Output: Suggested dishes.

[0200] Step 6:

[0201] The server returns the suggested dishes to the device in JSON format. Specifically, it converts the information about the selected dish into JSON format and sends it to the device via API. Input: Suggested dishes. Output: Dish information in JSON format.

[0202] Step 7:

[0203] The device displays the recipe information received from the server to the user, allowing the user to confirm the most suitable recipe. Specifically, it updates the app's UI and displays a list of suggested recipes. Input: JSON-formatted recipe information. Output: Display to the user.

[0204] Step 8:

[0205] The user finally selects the dish they wish to order from the suggested dishes and presses the order confirmation button. Specifically, the ID of the dish selected by the user is resent from the terminal to the server. Input: User's dish selection. Output: Information about the selected dish.

[0206] Step 9:

[0207] The server sends the order information for the dishes selected by the user to the restaurant. Specifically, the information about the selected dishes is sent to the restaurant using a food delivery API. Input: Information about the selected dishes. Output: Order information sent to the restaurant.

[0208] Step 10:

[0209] The restaurant prepares the ordered food and starts the delivery process. Specifically, it cooks the food according to the order information and hands it over to the delivery company. Input: Order information to the restaurant. Output: Prepared food and delivery information.

[0210] Step 11:

[0211] The terminal notifies the user of the progress of the delivery process. Specifically, progress information from the restaurant and delivery company is displayed in real time within the app. Input: Delivery information. Output: Notification to the user.

[0212] Step 12:

[0213] The user can receive the delivered food and enjoy the meal. Specifically, the user dines based on the provided food. Input: Delivered food. Output: User satisfaction.

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

[0215] The present invention relates to an online recipe creation system for enhancing a user's dining experience. This system receives user preference information, dietary restriction information, and ingredient information, and generates and provides recipes based on this information. In addition, by combining it with an emotion engine, it can provide personalized recipes that take the user's emotional state into consideration.

[0216] A natural language description of the program's operation

[0217] User

[0218] First, the user inputs their preferences (e.g., "Italian food," "low carbohydrates," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken") into the system. The system also recognizes the user's emotional state. Once the user logs in and presses the "Generate Recipe" button, this information is processed.

[0219] Terminal

[0220] The terminal (user's device) provides an interface to acquire user input and emotional state. When the user inputs information and presses the recipe generation button, the terminal sends this information in JSON format to the server.

[0221] server

[0222] The server receives the user information sent from the terminal and performs the following processing.

[0223] 1. Extract user information:

[0224] The server extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state from the received data.

[0225] 2. Filtering recipes:

[0226] The server filters all recipes in the database based on the user's preferences and dietary restrictions, selecting recipes that meet the user's specified criteria, and also considers the user's emotional state, prioritizing recipes that match the user's current emotions.

[0227] 3. Considering ingredient information:

[0228] The server then performs further filtering based on the user's ingredient information, giving priority to recipes that contain ingredients that the user owns.

[0229] 4. Use historical sentiment data:

[0230] The server also takes into account past emotion data stored by the emotion engine to select recipes to provide a consistent user experience.

[0231] 5. Random recipe selection:

[0232] From the filtered recipes, the server randomly selects one recipe.

[0233] 6. Recipe provided:

[0234] The selected recipe is returned to the terminal in JSON format.

[0235] Specific examples

[0236] For example, consider the case where user "user1" enters the following information and the emotion engine recognizes that the user is "feeling stressed":

[0237] Preferences: "Italian food" and "low carbohydrates"

[0238] Dietary Information: "Gluten Free"

[0239] Ingredients: "Tomato" "Chicken"

[0240] When the user presses the recipe generation button, the device sends this information to the server. The server then filters the information and prioritizes recipes that are expected to reduce the user's stress. In this case, an appropriate recipe that is expected to have a relaxing effect, such as "Chicken Alfredo," is selected as a candidate. The server then returns the final selected recipe to the device, which displays it to the user.

[0241] As described above, by taking into account the user's emotional state in addition to their preferences and dietary restrictions, more personalized recipes can be provided, enhancing the user's dining experience.

[0242] The processing flow will be explained below.

[0243] Step 1:

[0244] A user logs into the platform and enters preference information (e.g., "Italian food," "low carb"), dietary restriction information (e.g., "gluten-free"), and ingredient information (e.g., "tomato," "chicken").

[0245] Step 2:

[0246] The device receives user input, converts it into JSON format, and prepares it for sending to the emotion engine.

[0247] Step 3:

[0248] The emotion engine recognizes the user's emotional state in real time and analyzes the emotion the user is feeling (e.g., "stress").

[0249] Step 4:

[0250] The device sends the user's preference information, dietary restriction information, ingredient information, and emotional state from the emotion engine to the server in JSON format.

[0251] Step 5:

[0252] The server processes the request received from the terminal and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state.

[0253] Step 6:

[0254] The server filters all recipes in the database based on your preferences and dietary restrictions, for example, selecting recipes that meet the criteria "Italian," "low carb," and "gluten-free."

[0255] Step 7:

[0256] The server considers the user's emotional state and prioritizes recipes that suit that emotional state, for example, recipes that are suitable for "reducing stress."

[0257] Step 8:

[0258] The server then takes into account the user's ingredient information and filters recipes that include ingredients (e.g., "tomato" or "chicken") as final candidates.

[0259] Step 9:

[0260] The server randomly selects one recipe from the filtered list.

[0261] Step 10:

[0262] The server returns the selected recipe to the device in JSON format.

[0263] Step 11:

[0264] The terminal analyzes the recipe information received from the server and displays it on the user interface.

[0265] Step 12:

[0266] The user checks the presented recipe and enjoys cooking.

[0267] Example 2

[0268] 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."

[0269] Conventional recipe generation systems are limited in providing recipes based on user preferences and dietary restrictions, and do not provide recipes that take into account the emotional state of each user. Furthermore, recipes that take into account ingredient information are also lacking, making it difficult to efficiently use ingredients available to users. Therefore, there is a growing need for a system that can comprehensively improve users' dining experiences.

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

[0271] In this invention, the server includes a means for receiving preference information, dietary restriction information, and emotional information from the user, a means for filtering recipes based on the preference information, dietary restriction information, and emotional information, and a means for taking the user's ingredient information into account during the filtering process. This allows for the provision of personalized recipes that take into account not only the user's preferences and dietary restrictions, but also their emotional state. Furthermore, by incorporating the user's own ingredient information, the user can use ingredients more efficiently, improving the overall dining experience.

[0272] "Preference information" is data that represents the user's preferences for specific ingredients and cooking styles.

[0273] "Dietary restriction information" is data about ingredients and nutrients that a user wants to avoid for health reasons or personal preferences.

[0274] "Emotion information" is data that indicates the user's current emotional state, and includes states such as "stress," "joy," and "sadness," for example.

[0275] "Ingredient information" is data that indicates a list of ingredients that the user currently owns.

[0276] "Filtering" is the process of selecting information from a database that meets certain conditions based on information received from a user.

[0277] "Randomly selecting" means randomly selecting one of the filtered candidates without using any particular algorithm.

[0278] "Subscription-based" is a service format in which users pay a fixed fee to use the system on a regular basis.

[0279] A "personalized recipe" is a recipe that is specially created based on a user's preference information, dietary restriction information, emotional information, and ingredient information.

[0280] The present invention relates to an online recipe generation system for enhancing a user's dining experience, which receives user preference information, dietary restriction information, ingredient information, and emotional information, and generates and provides personalized recipes based on this information.

[0281] System configuration

[0282] User

[0283] Users input their preferences (e.g., "Italian food," "low carbohydrate," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken," etc.) into the system. Furthermore, the system recognizes their emotional state. This information is transmitted to the system via the user's device.

[0284] Terminal

[0285] The terminal (user's device) provides an interface to acquire user input and emotional state. When the user inputs information and presses the recipe generation button, the terminal sends this information in JSON format to the server.

[0286] server

[0287] The server receives the JSON data sent from the device and performs the following operations:

[0288] 1. Extract user information:

[0289] The server extracts the user ID, preference information, dietary restriction information, ingredient information, and emotion information from the received data.

[0290] 2. Filtering recipes:

[0291] The server filters all recipes in the database based on the user's preferences and dietary restrictions, and also takes into account the user's emotional state to prioritize recipes that are currently suitable for the user.

[0292] 3. Considering ingredient information:

[0293] The server further filters the recipes taking into account the ingredient information the user has.

[0294] 4. Use historical sentiment data:

[0295] The server references past emotion data stored by the emotion engine to assist in selecting recipes to provide a consistent user experience.

[0296] 5. Random recipe selection:

[0297] From the filtered recipes, the server randomly selects one recipe.

[0298] 6. Recipe provided:

[0299] The selected recipe is sent in JSON format to the terminal, which displays it to the user.

[0300] Specific examples

[0301] For example, consider the case where user "user1" enters the following information and the emotion engine recognizes that the user is "feeling stressed":

[0302] Preferences: "Italian food" and "low carbohydrates"

[0303] Dietary Information: "Gluten Free"

[0304] Ingredients: "Tomato" "Chicken"

[0305] When the user presses the recipe generation button, the device sends this information to the server. The server then filters the information and prioritizes recipes that are expected to reduce the user's stress. In this case, an appropriate recipe that is expected to have a relaxing effect, such as "Chicken Alfredo," is selected as a candidate. The server then returns the selected recipe in JSON format to the device, which then displays it to the user.

[0306] Example prompts for generative AI models

[0307] Examples of prompts for generative AI models include:

[0308] "Design a system that generates personalized recipes based on a user's preferences, dietary restrictions, and ingredients. Also consider the user's emotional state."

[0309] Includes:

[0310] The system can improve a user's overall dining experience by providing more personalized recipes based on the user's individual needs.

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

[0312] Step 1:

[0313] Entering user information

[0314] Users input their preferences (e.g., "Italian food," "low carbohydrates," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken," etc.) into the terminal. The system also recognizes the user's emotional state.

[0315] Input: User preferences, dietary restrictions, ingredients, and emotional state

[0316] Output: Data summarizing the information entered by the user

[0317] What it does: The user enters information into an application form and uses facial expression analysis cameras and other features to automatically recognize emotional states.

[0318] Step 2:

[0319] Sending information

[0320] When the user presses the recipe generation button, the terminal converts the entered information into JSON format and sends it to the server.

[0321] Input: User-entered preferences, dietary restrictions, ingredients, and emotional state

[0322] Output: User information converted to JSON format

[0323] Specific behavior: Converts data collected from the input form into JSON format and sends it to the server as an HTTP POST request.

[0324] Step 3:

[0325] Receiving and extracting user information

[0326] The server receives the JSON data sent from the device and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional information.

[0327] Input: JSON data sent from the terminal

[0328] Output: Extracted user ID, preference information, dietary restriction information, ingredient information, and emotional information

[0329] Specific behavior: The server's API endpoint parses the JSON data and stores each item in a variable.

[0330] Step 4:

[0331] Initial filtering of recipes

[0332] The server filters the recipes in the database based on the user's preference and dietary restriction information.

[0333] Input: User preferences and dietary restrictions

[0334] Output: Filtered recipe list

[0335] What it does: Extracts recipes that match the preferences and dietary restrictions using a database query (e.g., SQL query).

[0336] Step 5:

[0337] Considering emotional states

[0338] The server prioritizes recipes that are appropriate for the user's emotions from among the recipes filtered based on the emotional state.

[0339] Input: User's emotional information

[0340] Output: A list of recipes further refined based on emotional state

[0341] What it does: Calls the emotion engine, tags recipes related to the emotional state, and adds them to the filtering criteria.

[0342] Step 6:

[0343] Consideration of ingredient information

[0344] The server further filters the recipes taking into account the ingredient information the user has.

[0345] Input: User's ingredient information

[0346] Output: A list of recipes using ingredients you have

[0347] What it does: Re-filter the database for matching recipes based on the ingredients.

[0348] Step 7:

[0349] Use of past emotion data

[0350] The server references previously collected emotion data and integrates it into the current filtering conditions.

[0351] Input: Historical emotion data

[0352] Output: A comprehensive recipe list that also takes into account sentiment data

[0353] What it does: It retrieves past emotion data from the emotion engine via a database query and integrates it into the current recipe selection.

[0354] Step 8:

[0355] Random recipe selection

[0356] The server randomly selects one recipe from the filtered list.

[0357] Input: Filtered recipe list

[0358] Output: A randomly selected recipe

[0359] What it does: Uses a random function to randomly select one recipe from the filtered list of recipes.

[0360] Step 9:

[0361] Recipe provided

[0362] The selected recipe is sent in JSON format to the terminal, which displays it to the user.

[0363] Input: A randomly selected recipe

[0364] Output: The recipe displayed to the user

[0365] Specific operation: Recipe information is converted into JSON format and sent to the terminal as an HTTP response, and the terminal displays the information to the user.

[0366] (Application example 2)

[0367] 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."

[0368] Conventional recipe generation systems suggest recipes based on basic information such as user preferences and dietary restrictions, but do not consider the user's emotional state. As a result, it is difficult to suggest recipes that are in line with the user's mood and emotions on that day. Furthermore, even if a recipe is suggested, there is no mechanism to provide related food delivery options, which means that it is not possible to reduce the effort required for actual meal preparation.

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

[0370] In this invention, the server comprises: means for recognizing the emotional state of the user and filtering recipes based on the emotional state;

[0371] means for receiving preference information and dietary restriction information from a user;

[0372] a means for randomly selecting a recipe from among the filtered recipes;

[0373] Includes:

[0374] This allows recipe suggestions to be tailored not only to a user's preferences but also to their emotional state. Furthermore, by including a means for providing delivery options for related foods, users can easily obtain the foods they need and reduce the effort required for meal preparation. Furthermore, by including a means for performing sentiment analysis using a generative AI model, advanced sentiment recognition becomes possible, resulting in more accurate and personalized recipe suggestions.

[0375] "User" refers to an individual who utilizes the system to receive recipes.

[0376] "Preference information" refers to information about the types of dishes and ingredients that a user particularly likes.

[0377] "Dietary restriction information" refers to information about ingredients and dishes that users should avoid for health or religious reasons.

[0378] "Ingredient information" refers to information about ingredients currently in the user's possession.

[0379] "Emotional state" refers to information about a user's current mood or emotions.

[0380] "Emotion analysis" refers to the technology of analyzing a user's emotional state.

[0381] A "recipe" refers to a list of instructions and ingredients for making a particular dish.

[0382] "Filtering" refers to the process of narrowing down options based on specific criteria.

[0383] "Generative AI model" refers to a mathematical model for generating data using artificial intelligence.

[0384] "Server" refers to a computer system that processes information received from users and generates and serves recipes.

[0385] "Delivery Option" refers to an option that provides a service to deliver related food based on a recipe selected by a user.

[0386] MODE FOR CARRYING OUT THE INVENTION

[0387] The present invention is a system that generates personalized recipes based on a user's preferences, dietary restrictions, available ingredients, and emotional state, and also suggests related delivery options. Specific embodiments of the present invention will be described.

[0388] System configuration

[0389] The system of the present invention comprises the following main components:

[0390] 1. User Device: A device used by a user to access the system, including a smartphone, tablet, or PC. The user device provides an interface for inputting user preference information, dietary restriction information, ingredient information, and emotional state.

[0391] 2. Server: A central computer system that receives and processes information sent from user devices. The server performs recipe filtering, sentiment analysis, and delivery option suggestions.

[0392] 3. Sentiment Analysis Software: Software for analyzing the user's emotional state. It can use IBM Watson's sentiment analysis API or other generative AI models.

[0393] System Operation

[0394] 1. User Input

[0395] Using a device with a dedicated application installed, users input their preferences, dietary restrictions, ingredients, and emotional state, which is then automatically recognized by emotion analysis software.

[0396] 2. Data transmission

[0397] Once the user enters the information, it is sent to the server in JSON format, allowing the server to parse and process the incoming data.

[0398] 3. Processing on the Server

[0399] The server does the following:

[0400] Extract user information: Extract user preference information, dietary restrictions, ingredient information, and emotional state from the received data.

[0401] Recipe filtering: Based on the extracted information, the database is filtered for suitable recipes, and sentiment analysis software is used to consider the user's emotional state and prioritize recipes that best fit their current emotions.

[0402] Random Selection: Randomly select one of the filtered recipes.

[0403] 4. Delivery options available

[0404] It suggests food delivery options related to the selected recipe, making it easy for users to get the ingredients they need.

[0405] 5. Return of Information

[0406] The selected recipe and delivery options are then sent back to the user's device in JSON format, where they are displayed to the user.

[0407] Hardware and software used

[0408] Hardware: User devices are smartphones, tablets, or PCs. Servers are high-performance computer systems.

[0409] Software: The front end is a smartphone application (iOS / Android), the back end is Python's Flask and PostgreSQL, and the sentiment analysis is performed using IBM Watson's sentiment analysis API.

[0410] Specific examples

[0411] For example, if user "user1" enters the following information:

[0412] Preferences: "Italian food" and "low carbohydrates"

[0413] Dietary Information: "Gluten Free"

[0414] Ingredients: "Tomato" "Chicken"

[0415] Emotional state: "Stress"

[0416] Based on this information, the server processes the data and selects an appropriate recipe, such as "Chicken Alfredo," along with delivery options for that related food. The selection is then sent back to the user's device, where the user can review and order delivery.

[0417] Prompt Sentence Examples

[0418] Preferences: "Italian food" and "low carbohydrates"

[0419] Dietary Information: "Gluten Free"

[0420] Ingredients: "Tomato" "Chicken"

[0421] Emotional state: "Stress"

[0422] Use this information to suggest the best recipes and delivery options.

[0423] As described above, the present invention can provide more accurate personalized recipes that take into account not only the user's preferences and dietary restrictions, but also their emotional state, and can also suggest delivery options to help them achieve these recipes.

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

[0425] Step 1:

[0426] User Input

[0427] Users use a dedicated application to input their preferences (e.g., Italian food, low carbohydrates), dietary restrictions (e.g., gluten-free), and ingredients (e.g., tomatoes, chicken). Furthermore, emotion analysis software collects the user's emotional state (e.g., stress) through the application.

[0428] Input: User preference information, dietary restriction information, ingredient information, emotional state

[0429] Output: Data collected by user devices

[0430] Step 2:

[0431] Data transmission

[0432] The device sends the collected user information to the server in JSON format.

[0433] Input: Data collected on the user device

[0434] Output: JSON data sent to the server

[0435] Step 3:

[0436] Extracting User Information

[0437] The server analyzes the received JSON data and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state.

[0438] Input: JSON data sent to the server

[0439] Output: Extracted user information

[0440] Step 4:

[0441] Recipe Filtering

[0442] The server filters the recipes in the database based on the extracted user information, specifically using emotion analysis software to prioritize recipes that are appropriate for the user's emotional state.

[0443] Input: Extracted user information

[0444] Data operations: filtering and prioritizing recipes in a database

[0445] Output: Filtered recipe list

[0446] Step 5:

[0447] Applying ingredient information

[0448] The server further performs additional filtering on the filtered recipe list, taking into account ingredient information possessed by the user.

[0449] Input: filtered recipe list, user ingredient information

[0450] Data processing: Selection of recipes that match the ingredient information

[0451] Output: Final filtered recipe list

[0452] Step 6:

[0453] Random Selection

[0454] The server then randomly selects one recipe from the final filtered list of recipes.

[0455] Input: Final filtered recipe list

[0456] Data calculation: Random selection

[0457] Output: Selected recipe

[0458] Step 7:

[0459] Delivery options

[0460] The server generates data suggesting related food delivery options based on the selected recipe.

[0461] Input: Selected recipe

[0462] Data processing: Searching and suggesting relevant food delivery options

[0463] Output: Delivery options list

[0464] Step 8:

[0465] Returning the results

[0466] The server returns the selected recipe and associated delivery options in JSON format to the user device.

[0467] Input: Selected recipe, delivery options list

[0468] Output: JSON data sent back to the user device

[0469] Step 9:

[0470] Displaying Information

[0471] The terminal parses the returned JSON data and displays the selected recipe and delivery options to the user.

[0472] Input: Returned JSON data

[0473] Output: What is displayed to the user

[0474] The above are the specific processing steps of the system for realizing the present invention.

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

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

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

[0478] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

[0489] In the smart glasses 214, 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.

[0490] 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."

[0491] The present invention relates to an online recipe creation system that enhances users' dining experiences. The system receives user preference information and dietary restriction information, and generates and serves appropriate recipes based on the information. It also allows filtering based on certain ingredient information and operates on a subscription basis.

[0492] A natural language description of the program's operation

[0493] User

[0494] First, users input their preferences (e.g., "Italian food," "low carbohydrates") and dietary restrictions (e.g., "gluten-free") into the system. Then, they log in and request a recipe. Users can also input specific ingredients they have on hand.

[0495] Terminal

[0496] The terminal (user's device) provides an interface for sending the user's input preference information, dietary restriction information, and ingredient information to the server. When the user presses the recipe generation button, the terminal sends this information to the server in JSON format.

[0497] server

[0498] The server receives the user information sent from the terminal and performs the following process.

[0499] 1. Extract user information:

[0500] The server extracts the user ID, preference information, dietary restriction information, and ingredient information from the received data.

[0501] 2. Filtering recipes:

[0502] The server filters all recipes in the database based on the user's preferences and dietary restrictions. For example, if a user selects "Italian" and "low carb" and specifies "gluten free" as a dietary restriction, only recipes that meet these criteria will be filtered.

[0503] 3. Considering ingredient information:

[0504] The server also takes into account the ingredient information entered by the user and performs further filtering. For example, if a user enters that they have "tomatoes" and "chicken," recipes containing these ingredients will be prioritized.

[0505] 4. Random recipe selection:

[0506] From the filtered recipes, the server randomly selects one recipe.

[0507] 5. Recipe provided:

[0508] The server returns the selected recipe to the terminal in JSON format.

[0509] Specific examples

[0510] For example, if user "user1" enters the following information:

[0511] Preferences: "Italian food" and "low carbohydrates"

[0512] Dietary Information: "Gluten Free"

[0513] Ingredients: "Tomato" "Chicken"

[0514] When the user presses the recipe generation button, the device sends this information to the server, which considers the user's preferences, dietary restrictions, and available ingredients to select an appropriate recipe, such as "Chicken Alfredo." The server then returns the recipe to the device, which displays it to the user.

[0515] This allows users to easily find suitable recipes based on their preferences, dietary restrictions, and available ingredients, allowing them to enjoy cooking. The system provides users with new cooking ideas and helps expand the variety of their meals.

[0516] The processing flow will be explained below.

[0517] Step 1:

[0518] The user logs into the platform and presses the recipe creation button.

[0519] Step 2:

[0520] The terminal displays an interface for inputting the user's preference information, dietary restriction information, and ingredient information.

[0521] Step 3:

[0522] The user inputs preference information (e.g., "Italian food," "low carbohydrate"), dietary restriction information (e.g., "gluten-free"), and ingredient information (e.g., "tomato," "chicken").

[0523] Step 4:

[0524] The device receives user input, converts it to JSON format, and sends it to the server.

[0525] Step 5:

[0526] The server processes the request received from the terminal and extracts the user ID, preference information, dietary restriction information, and ingredient information.

[0527] Step 6:

[0528] The server filters all recipes in the database based on the preference and dietary restriction information, selecting recipes that match the user's specified preferences and do not violate any dietary restrictions.

[0529] Step 7:

[0530] The server further filters the recipes based on the user's ingredient information, giving priority to recipes that include ingredients that the user owns.

[0531] Step 8:

[0532] The server randomly selects one recipe from the filtered list.

[0533] Step 9:

[0534] The server returns the selected recipe to the device in JSON format.

[0535] Step 10:

[0536] The terminal analyzes the recipe information received from the server and displays it on the user interface.

[0537] Step 11:

[0538] The user checks the presented recipe and enjoys cooking.

[0539] Example 1

[0540] 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."

[0541] Conventional recipe search systems have difficulty in considering detailed user preferences, dietary restrictions, and ingredients available on hand, making it difficult for users to quickly obtain the information they need. Furthermore, they do not adequately provide recipes that meet the individual needs of users, making it difficult to improve the variety and satisfaction of meals.

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

[0543] In this invention, the server includes means for receiving preference information and dietary restriction information from a user, means for filtering suitable recipes based on the preference information and dietary restriction information, means for receiving ingredient information from the user, means for filtering recipes taking the ingredient information into consideration, means for randomly selecting a recipe from the filtered recipes, means for providing the selected recipe to the user, means for the user to log in and transmit authentication information to the server, and means operated on a subscription basis for the user to periodically receive personalized recipes. This allows users to quickly obtain recipes based on their detailed preferences and restrictions, thereby improving the variety and satisfaction of their meals.

[0544] "User" refers to a person who uses the system and inputs information such as their preferences, dietary restrictions, and ingredients.

[0545] "Preference information" refers to information that serves as the basis for selecting a particular recipe, such as the user's type of cuisine and nutritional restrictions.

[0546] "Dietary restriction information" refers to information about a user's allergies or nutritional restrictions, such as information to avoid certain foods or ingredients.

[0547] "Ingredient information" refers to information about specific ingredients that the user already owns, and is taken into consideration when selecting a recipe.

[0548] "Filtering" refers to the process of sorting data based on specific conditions and extracting only the relevant items.

[0549] "Randomly select" means to randomly select one of the filtered items.

[0550] "Server" refers to a central computer system that processes information received from users and provides the necessary data.

[0551] A "terminal" is a device that allows a user to access a system and is responsible for input and display.

[0552] "Authentication information" is information used to verify a user's identity, and typically consists of a user ID and password.

[0553] "Subscription-based" refers to a method of using a service by paying a recurring fee, which allows users to receive personalized content on a regular basis.

[0554] "JSON format" is an abbreviation for JavaScript Object Notation, and refers to a lightweight data exchange format for describing data in a structured text format.

[0555] The present invention relates to an online recipe generation system that enhances a user's dining experience. The system receives a user's preference information and dietary restriction information, and generates and serves appropriate recipes based on that information. It can also provide more personalized recipes by taking into account specific ingredient information the user has.

[0556] User

[0557] First, a user enters their preferences (e.g., "Italian food," "low carbohydrates," etc.) and dietary restrictions (e.g., "gluten-free") into the system. Next, they log in to their account and request recipe generation. The user can also enter specific ingredient information (e.g., "tomato," "chicken," etc.) that they have on hand. This information is sent to the server via their terminal.

[0558] Terminal

[0559] The terminal (user's device) converts the user's input preferences, dietary restrictions, and ingredient information into JSON format and sends it to the server. The terminal also sends the user's login authentication information to the server. The filtered recipe is sent back to the terminal and displayed to the user.

[0560] server

[0561] When the server receives the user information sent from the device, it analyzes the JSON-formatted data and extracts preference information, dietary restriction information, and ingredient information. Based on this information, the server filters all recipes in the database. It then further filters the recipes taking into account ingredient information. From the recipes obtained as a result of the filtering, the server randomly selects one recipe and returns it to the device in JSON format.

[0562] Specific examples

[0563] For example, if user "user1" enters the following information:

[0564] Preferences: "Italian food" and "low carbohydrates"

[0565] Dietary Information: "Gluten Free"

[0566] Ingredients: "Tomato" "Chicken"

[0567] When the user presses the recipe generation button, the device sends this information to the server, which considers the user's preferences, dietary restrictions, and available ingredients to select an appropriate recipe, such as "Chicken Alfredo." The server then returns the recipe to the device, which displays it to the user.

[0568] Example prompt sentence:

[0569] Can you recommend some "Italian" and "low carb" recipes that are "gluten free" and contain "tomatoes" and "chicken"?

[0570] In this way, users can quickly obtain optimal recipes based on their own preferences and restrictions using ingredients they have on hand. This system provides users with new cooking ideas and improves the variety and satisfaction of their meals.

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

[0572] Step 1: The user logs into the system.

[0573] Input: User ID and password

[0574] Output: Authentication token

[0575] Specific operation: The user enters their user ID and password on the login screen and sends them to the terminal. The terminal then sends that information to the server. The server verifies the received information, and if the user is legitimate, generates an authentication token and sends it back to the terminal.

[0576] Step 2: The user inputs preference information, dietary restriction information, and ingredient information.

[0577] Input: Preference information (e.g., "Italian food" or "low carb"), dietary restriction information (e.g., "gluten-free"), ingredient information (e.g., "tomato" or "chicken")

[0578] Output: Request data in JSON format

[0579] Specific operation: The user inputs various information using a dedicated input interface, and the device converts this information into JSON format.

[0580] Step 3: The terminal transmits the user's input information to the server.

[0581] Input: Request data in JSON format

[0582] Output: Send data to the server

[0583] Specific operation: The device sends the user's preference information, dietary restriction information, and ingredient information in JSON format to the server. The sent data, including user authentication, is packetized and sent to the server.

[0584] Step 4: The server parses and extracts the user information.

[0585] Input: Request data in JSON format

[0586] Output: User, preferences, dietary restrictions, and ingredient information

[0587] Specific operation: The server parses the received JSON data and extracts the user ID, preference information, dietary restriction information, and ingredient information. This data is temporarily stored in the server's memory.

[0588] Step 5: The server filters the recipes based on the preference information and dietary restriction information.

[0589] Input: Preferences and dietary restrictions

[0590] Output: Filtered recipe list

[0591] What happens: The server filters all recipes in the database to find those that match the user's preferences and dietary restrictions. For example, it selects only "Italian," "low carb," and "gluten-free" recipes.

[0592] Step 6: The server further filters the recipes taking into account the ingredient information.

[0593] Input: filtered recipe list, ingredient information

[0594] Output: A list of recipes filtered by ingredients.

[0595] Specific operation: The server further filters the recipe list obtained from the first filtering, taking into account the ingredient information possessed by the user, and extracts only recipes that contain the relevant ingredients. For example, it extracts only recipes that contain "tomato" and "chicken."

[0596] Step 7: The server randomly selects a recipe from the filtered recipes.

[0597] Input: A list of recipes filtered by ingredients

[0598] Output: Selected recipes

[0599] Specific operation: The server randomly selects one recipe from the list of recipes obtained by the above filtering. This selection process is performed randomly using a random number generator or the like.

[0600] Step 8: The server returns the selected recipe to the terminal in JSON format.

[0601] Input: Selected recipe

[0602] Output: Recipe data in JSON format

[0603] What it does: The server converts a randomly selected recipe into JSON format and sends it to the device. The device receives the data and returns a confirmation to the server that it was received successfully.

[0604] Step 9: The terminal displays the received recipe to the user.

[0605] Input: Recipe data in JSON format

[0606] Output: The recipe displayed in the user interface

[0607] Specific operation: The device parses the received JSON data and extracts the recipe information. The extracted recipe information is displayed on the screen in a format that the user can view. This allows the user to view recipes based on their preferences and restrictions.

[0608] (Application example 1)

[0609] 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."

[0610] In conventional food delivery services, it is difficult for users to select appropriate dishes based on their preferences and dietary restrictions. In addition, due to the lack of a system to quickly find suitable recipes and dishes, users have to spend time searching for dishes that suit them. This makes it particularly difficult for users with specific dietary restrictions or preferences to choose a satisfying meal.

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

[0612] In this invention, the server includes means for receiving preference information and dietary restriction information from a user, means for filtering suitable dishes based on the preference information and dietary restriction information, means for suggesting appropriate dishes from among the filtered dishes, and means for providing the suggested dishes to the user and ordering the appropriate dishes, thereby enabling the user to easily select and quickly order the optimal dishes based on their preferences and dietary restrictions.

[0613] "User preference information" refers to information such as the type of food, seasoning, cooking method, etc. that the user prefers.

[0614] "Dietary restriction information" refers to information about ingredients or foods that a user should avoid, such as restrictions due to allergies, health conditions, or religious reasons.

[0615] "Filtering" refers to the process of narrowing down items in a database based on specific criteria.

[0616] "Means for suggesting appropriate dishes" refers to a function within the system for selecting and suggesting optimal dishes based on the user's preference information and dietary restriction information.

[0617] "Means for ordering food" refers to a function within the system for executing the process of ordering the food selected by the user from a food service provider.

[0618] The present invention relates to a system that suggests optimal dishes based on a user's preference information and dietary restriction information, and enables the user to order through a food delivery service.

[0619] To implement the invention, the following configurations and processes are included.

[0620] User

[0621] A user uses a smartphone app to input their preferences (e.g., Italian food, low carb, etc.) and dietary restrictions (e.g., gluten-free). This information is entered through the app's interface. Once the user confirms their order, this information is sent to the server through the app's interface. As a concrete example, suppose the user inputs "Italian food," "low carb," and "gluten-free."

[0622] Terminal

[0623] The terminal provides an interface for sending the user's preference information and dietary restriction information to the server. This interface has a mechanism for sending data to the server in JSON format, for example. When the user presses the order confirmation button, the terminal sends this information to the server.

[0624] server

[0625] The server processes the received user information and proposes the most suitable dish. Specifically, it performs the following process.

[0626] 1. Extract user information:

[0627] The server extracts the user ID, preference information, and dietary restriction information from the received data.

[0628] 2. Cuisine filtering:

[0629] The server filters all dishes in the food delivery service's database based on the user's preferences and dietary restrictions. For example, if the user selects "Italian," "low carb," and "gluten-free," only dishes that meet these criteria will be filtered.

[0630] 3. Food suggestions:

[0631] From the filtered dishes, the server suggests appropriate dishes and returns them to the terminal in JSON format.

[0632] 4. Manage your orders:

[0633] Once the user selects a suggested dish and confirms the order, the information is sent to the restaurant, and once the food is ready, the user is notified of delivery information.

[0634] Hardware and software used

[0635] The hardware used includes a standard smartphone and server. The software includes a smartphone application and a back-end system that implements a server-side recipe filtering algorithm. It also includes a part that calls a food delivery API to retrieve and select dish information.

[0636] Specific examples

[0637] For example, if user "user1" enters the following information:

[0638] Preferences: "Italian food" and "low carbohydrates"

[0639] Dietary Information: "Gluten Free"

[0640] When the user presses the order confirmation button, the device sends this information to the server. The server considers the user's preferences and dietary restrictions, suggests appropriate dishes, and sends them back to the device. Once the user selects the most suitable dish, they can confirm the order and the food will be delivered from the restaurant.

[0641] Prompt Sentence Examples

[0642] A user has entered their preferences (Italian, low carb) and dietary restrictions (gluten free). Using this information, use a food delivery API to suggest a list of dishes that would best suit the user.

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

[0644] Step 1:

[0645] Users use a smartphone app to input their preferences (e.g., Italian food, low carbohydrates, etc.) and dietary restrictions (e.g., gluten-free). This information is prepared as JSON-formatted data in the app's interface. Input: User preferences and dietary restrictions. Output: User information in JSON format.

[0646] Step 2:

[0647] The device sends the preference information and dietary restriction information entered by the user to the server. Specifically, when the user presses the order confirmation button, the device sends this information to the server via the in-app API. Input: User information in JSON format. Output: Information sent to the server.

[0648] Step 3:

[0649] The server processes the data received from the device and extracts the user ID, preference information, and dietary restriction information. Specifically, the server parses the received JSON data and stores the necessary information in variables. Input: User information in JSON format. Output: Extracted user information.

[0650] Step 4:

[0651] The server filters all dishes in the database based on the user's preferences and dietary restrictions. Specifically, it uses SQL queries to extract only the dishes that match the preferences and restrictions and stores them in a temporary database. Input: Extracted user information. Output: Filtered list of dishes.

[0652] Step 5:

[0653] The server then suggests appropriate dishes from the filtered list. Specifically, it sorts the filtered list of dishes using an algorithm and selects the most suitable dish. Input: Filtered list of dishes. Output: Suggested dishes.

[0654] Step 6:

[0655] The server returns the suggested dishes to the device in JSON format. Specifically, it converts the information about the selected dish into JSON format and sends it to the device via API. Input: Suggested dishes. Output: Dish information in JSON format.

[0656] Step 7:

[0657] The device displays the recipe information received from the server to the user, allowing the user to confirm the most suitable recipe. Specifically, it updates the app's UI and displays a list of suggested recipes. Input: JSON-formatted recipe information. Output: Display to the user.

[0658] Step 8:

[0659] The user finally selects the dish they wish to order from the suggested dishes and presses the order confirmation button. Specifically, the ID of the dish selected by the user is resent from the terminal to the server. Input: User's dish selection. Output: Information about the selected dish.

[0660] Step 9:

[0661] The server sends the order information for the dishes selected by the user to the restaurant. Specifically, the information about the selected dishes is sent to the restaurant using a food delivery API. Input: Information about the selected dishes. Output: Order information sent to the restaurant.

[0662] Step 10:

[0663] The restaurant prepares the ordered food and starts the delivery process. Specifically, it cooks the food according to the order information and hands it over to the delivery company. Input: Order information to the restaurant. Output: Prepared food and delivery information.

[0664] Step 11:

[0665] The terminal notifies the user of the progress of the delivery process. Specifically, progress information from the restaurant and delivery company is displayed in real time within the app. Input: Delivery information. Output: Notification to the user.

[0666] Step 12:

[0667] The user can receive the delivered food and enjoy the meal. Specifically, the user dines based on the provided food. Input: Delivered food. Output: User satisfaction.

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

[0669] The present invention relates to an online recipe creation system for enhancing a user's dining experience. This system receives user preference information, dietary restriction information, and ingredient information, and generates and provides recipes based on this information. In addition, by combining it with an emotion engine, it can provide personalized recipes that take the user's emotional state into consideration.

[0670] A natural language description of the program's operation

[0671] User

[0672] First, the user inputs their preferences (e.g., "Italian food," "low carbohydrates," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken") into the system. The system also recognizes the user's emotional state. Once the user logs in and presses the "Generate Recipe" button, this information is processed.

[0673] Terminal

[0674] The terminal (user's device) provides an interface to acquire user input and emotional state. When the user inputs information and presses the recipe generation button, the terminal sends this information in JSON format to the server.

[0675] server

[0676] The server receives the user information sent from the terminal and performs the following processing.

[0677] 1. Extract user information:

[0678] The server extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state from the received data.

[0679] 2. Filtering recipes:

[0680] The server filters all recipes in the database based on the user's preferences and dietary restrictions, selecting recipes that meet the user's specified criteria, and also considers the user's emotional state, prioritizing recipes that match the user's current emotions.

[0681] 3. Considering ingredient information:

[0682] The server then performs further filtering based on the user's ingredient information, giving priority to recipes that contain ingredients that the user owns.

[0683] 4. Use historical sentiment data:

[0684] The server also takes into account past emotion data stored by the emotion engine to select recipes to provide a consistent user experience.

[0685] 5. Random recipe selection:

[0686] From the filtered recipes, the server randomly selects one recipe.

[0687] 6. Recipe provided:

[0688] The selected recipe is returned to the terminal in JSON format.

[0689] Specific examples

[0690] For example, consider the case where user "user1" enters the following information and the emotion engine recognizes that the user is "feeling stressed":

[0691] Preferences: "Italian food" and "low carbohydrates"

[0692] Dietary Information: "Gluten Free"

[0693] Ingredients: "Tomato" "Chicken"

[0694] When the user presses the recipe generation button, the device sends this information to the server. The server then filters the information and prioritizes recipes that are expected to reduce the user's stress. In this case, an appropriate recipe that is expected to have a relaxing effect, such as "Chicken Alfredo," is selected as a candidate. The server then returns the final selected recipe to the device, which displays it to the user.

[0695] As described above, by taking into account the user's emotional state in addition to their preferences and dietary restrictions, more personalized recipes can be provided, enhancing the user's dining experience.

[0696] The processing flow will be explained below.

[0697] Step 1:

[0698] A user logs into the platform and enters preference information (e.g., "Italian food," "low carb"), dietary restriction information (e.g., "gluten-free"), and ingredient information (e.g., "tomato," "chicken").

[0699] Step 2:

[0700] The device receives user input, converts it into JSON format, and prepares it for sending to the emotion engine.

[0701] Step 3:

[0702] The emotion engine recognizes the user's emotional state in real time and analyzes the emotion the user is feeling (e.g., "stress").

[0703] Step 4:

[0704] The device sends the user's preference information, dietary restriction information, ingredient information, and emotional state from the emotion engine to the server in JSON format.

[0705] Step 5:

[0706] The server processes the request received from the terminal and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state.

[0707] Step 6:

[0708] The server filters all recipes in the database based on your preferences and dietary restrictions, for example, selecting recipes that meet the criteria "Italian," "low carb," and "gluten-free."

[0709] Step 7:

[0710] The server considers the user's emotional state and prioritizes recipes that suit that emotional state, for example, recipes that are suitable for "reducing stress."

[0711] Step 8:

[0712] The server then takes into account the user's ingredient information and filters recipes that include ingredients (e.g., "tomato" or "chicken") as final candidates.

[0713] Step 9:

[0714] The server randomly selects one recipe from the filtered list.

[0715] Step 10:

[0716] The server returns the selected recipe to the device in JSON format.

[0717] Step 11:

[0718] The terminal analyzes the recipe information received from the server and displays it on the user interface.

[0719] Step 12:

[0720] The user checks the presented recipe and enjoys cooking.

[0721] Example 2

[0722] 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."

[0723] Conventional recipe generation systems are limited in providing recipes based on user preferences and dietary restrictions, and do not provide recipes that take into account the emotional state of each user. Furthermore, recipes that take into account ingredient information are also lacking, making it difficult to efficiently use ingredients available to users. Therefore, there is a growing need for a system that can comprehensively improve users' dining experiences.

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

[0725] In this invention, the server includes a means for receiving preference information, dietary restriction information, and emotional information from the user, a means for filtering recipes based on the preference information, dietary restriction information, and emotional information, and a means for taking the user's ingredient information into account during the filtering process. This allows for the provision of personalized recipes that take into account not only the user's preferences and dietary restrictions, but also their emotional state. Furthermore, by incorporating the user's own ingredient information, the user can use ingredients more efficiently, improving the overall dining experience.

[0726] "Preference information" is data that represents the user's preferences for specific ingredients and cooking styles.

[0727] "Dietary restriction information" is data about ingredients and nutrients that a user wants to avoid for health reasons or personal preferences.

[0728] "Emotion information" is data that indicates the user's current emotional state, and includes states such as "stress," "joy," and "sadness," for example.

[0729] "Ingredient information" is data that indicates a list of ingredients that the user currently owns.

[0730] "Filtering" is the process of selecting information from a database that meets certain conditions based on information received from a user.

[0731] "Randomly selecting" means randomly selecting one of the filtered candidates without using any particular algorithm.

[0732] "Subscription-based" is a service format in which users pay a fixed fee to use the system on a regular basis.

[0733] A "personalized recipe" is a recipe that is specially created based on a user's preference information, dietary restriction information, emotional information, and ingredient information.

[0734] The present invention relates to an online recipe generation system for enhancing a user's dining experience, which receives user preference information, dietary restriction information, ingredient information, and emotional information, and generates and provides personalized recipes based on this information.

[0735] System configuration

[0736] User

[0737] Users input their preferences (e.g., "Italian food," "low carbohydrate," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken," etc.) into the system. Furthermore, the system recognizes their emotional state. This information is transmitted to the system via the user's device.

[0738] Terminal

[0739] The terminal (user's device) provides an interface to acquire user input and emotional state. When the user inputs information and presses the recipe generation button, the terminal sends this information in JSON format to the server.

[0740] server

[0741] The server receives the JSON data sent from the device and performs the following operations:

[0742] 1. Extract user information:

[0743] The server extracts the user ID, preference information, dietary restriction information, ingredient information, and emotion information from the received data.

[0744] 2. Filtering recipes:

[0745] The server filters all recipes in the database based on the user's preferences and dietary restrictions, and also takes into account the user's emotional state to prioritize recipes that are currently suitable for the user.

[0746] 3. Considering ingredient information:

[0747] The server further filters the recipes taking into account the ingredient information the user has.

[0748] 4. Use historical sentiment data:

[0749] The server references past emotion data stored by the emotion engine to assist in selecting recipes to provide a consistent user experience.

[0750] 5. Random recipe selection:

[0751] From the filtered recipes, the server randomly selects one recipe.

[0752] 6. Recipe provided:

[0753] The selected recipe is sent in JSON format to the terminal, which displays it to the user.

[0754] Specific examples

[0755] For example, consider the case where user "user1" enters the following information and the emotion engine recognizes that the user is "feeling stressed":

[0756] Preferences: "Italian food" and "low carbohydrates"

[0757] Dietary Information: "Gluten Free"

[0758] Ingredients: "Tomato" "Chicken"

[0759] When the user presses the recipe generation button, the device sends this information to the server. The server then filters the information and prioritizes recipes that are expected to reduce the user's stress. In this case, an appropriate recipe that is expected to have a relaxing effect, such as "Chicken Alfredo," is selected as a candidate. The server then returns the selected recipe in JSON format to the device, which then displays it to the user.

[0760] Example prompts for generative AI models

[0761] Examples of prompts for generative AI models include:

[0762] "Design a system that generates personalized recipes based on a user's preferences, dietary restrictions, and ingredients. Also consider the user's emotional state."

[0763] Includes:

[0764] The system can improve a user's overall dining experience by providing more personalized recipes based on the user's individual needs.

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

[0766] Step 1:

[0767] Entering user information

[0768] Users input their preferences (e.g., "Italian food," "low carbohydrates," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken," etc.) into the terminal. The system also recognizes the user's emotional state.

[0769] Input: User preferences, dietary restrictions, ingredients, and emotional state

[0770] Output: Data summarizing the information entered by the user

[0771] What it does: The user enters information into an application form and uses facial expression analysis cameras and other features to automatically recognize emotional states.

[0772] Step 2:

[0773] Sending information

[0774] When the user presses the recipe generation button, the terminal converts the entered information into JSON format and sends it to the server.

[0775] Input: User-entered preferences, dietary restrictions, ingredients, and emotional state

[0776] Output: User information converted to JSON format

[0777] Specific behavior: Converts data collected from the input form into JSON format and sends it to the server as an HTTP POST request.

[0778] Step 3:

[0779] Receiving and extracting user information

[0780] The server receives the JSON data sent from the device and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional information.

[0781] Input: JSON data sent from the terminal

[0782] Output: Extracted user ID, preference information, dietary restriction information, ingredient information, and emotional information

[0783] Specific behavior: The server's API endpoint parses the JSON data and stores each item in a variable.

[0784] Step 4:

[0785] Initial filtering of recipes

[0786] The server filters the recipes in the database based on the user's preference and dietary restriction information.

[0787] Input: User preferences and dietary restrictions

[0788] Output: Filtered recipe list

[0789] What it does: Extracts recipes that match the preferences and dietary restrictions using a database query (e.g., SQL query).

[0790] Step 5:

[0791] Considering emotional states

[0792] The server prioritizes recipes that are appropriate for the user's emotions from among the recipes filtered based on the emotional state.

[0793] Input: User's emotional information

[0794] Output: A list of recipes further refined based on emotional state

[0795] What it does: Calls the emotion engine, tags recipes related to the emotional state, and adds them to the filtering criteria.

[0796] Step 6:

[0797] Consideration of ingredient information

[0798] The server further filters the recipes taking into account the ingredient information the user has.

[0799] Input: User's ingredient information

[0800] Output: A list of recipes using ingredients you have

[0801] What it does: Re-filter the database for matching recipes based on the ingredients.

[0802] Step 7:

[0803] Use of past emotion data

[0804] The server references previously collected emotion data and integrates it into the current filtering conditions.

[0805] Input: Historical emotion data

[0806] Output: A comprehensive recipe list that also takes into account sentiment data

[0807] What it does: It retrieves past emotion data from the emotion engine via a database query and integrates it into the current recipe selection.

[0808] Step 8:

[0809] Random recipe selection

[0810] The server randomly selects one recipe from the filtered list.

[0811] Input: Filtered recipe list

[0812] Output: A randomly selected recipe

[0813] What it does: Uses a random function to randomly select one recipe from the filtered list of recipes.

[0814] Step 9:

[0815] Recipe provided

[0816] The selected recipe is sent in JSON format to the terminal, which displays it to the user.

[0817] Input: A randomly selected recipe

[0818] Output: The recipe displayed to the user

[0819] Specific operation: Recipe information is converted into JSON format and sent to the terminal as an HTTP response, and the terminal displays the information to the user.

[0820] (Application example 2)

[0821] 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."

[0822] Conventional recipe generation systems suggest recipes based on basic information such as user preferences and dietary restrictions, but do not consider the user's emotional state. As a result, it is difficult to suggest recipes that are in line with the user's mood and emotions on that day. Furthermore, even if a recipe is suggested, there is no mechanism to provide related food delivery options, which means that it is not possible to reduce the effort required for actual meal preparation.

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

[0824] In this invention, the server comprises: means for recognizing the emotional state of the user and filtering recipes based on the emotional state;

[0825] means for receiving preference information and dietary restriction information from a user;

[0826] a means for randomly selecting a recipe from among the filtered recipes;

[0827] Includes:

[0828] This allows recipe suggestions to be tailored not only to a user's preferences but also to their emotional state. Furthermore, by including a means for providing delivery options for related foods, users can easily obtain the foods they need and reduce the effort required for meal preparation. Furthermore, by including a means for performing sentiment analysis using a generative AI model, advanced sentiment recognition becomes possible, resulting in more accurate and personalized recipe suggestions.

[0829] "User" refers to an individual who utilizes the system to receive recipes.

[0830] "Preference information" refers to information about the types of dishes and ingredients that a user particularly likes.

[0831] "Dietary restriction information" refers to information about ingredients and dishes that users should avoid for health or religious reasons.

[0832] "Ingredient information" refers to information about ingredients currently in the user's possession.

[0833] "Emotional state" refers to information about a user's current mood or emotions.

[0834] "Emotion analysis" refers to the technology of analyzing a user's emotional state.

[0835] A "recipe" refers to a list of instructions and ingredients for making a particular dish.

[0836] "Filtering" refers to the process of narrowing down options based on specific criteria.

[0837] "Generative AI model" refers to a mathematical model for generating data using artificial intelligence.

[0838] "Server" refers to a computer system that processes information received from users and generates and serves recipes.

[0839] "Delivery Option" refers to an option that provides a service to deliver related food based on a recipe selected by a user.

[0840] MODE FOR CARRYING OUT THE INVENTION

[0841] The present invention is a system that generates personalized recipes based on a user's preferences, dietary restrictions, available ingredients, and emotional state, and also suggests related delivery options. Specific embodiments of the present invention will be described.

[0842] System configuration

[0843] The system of the present invention comprises the following main components:

[0844] 1. User Device: A device used by a user to access the system, including a smartphone, tablet, or PC. The user device provides an interface for inputting user preference information, dietary restriction information, ingredient information, and emotional state.

[0845] 2. Server: A central computer system that receives and processes information sent from user devices. The server performs recipe filtering, sentiment analysis, and delivery option suggestions.

[0846] 3. Sentiment Analysis Software: Software for analyzing the user's emotional state. It can use IBM Watson's sentiment analysis API or other generative AI models.

[0847] System Operation

[0848] 1. User Input

[0849] Using a device with a dedicated application installed, users input their preferences, dietary restrictions, ingredients, and emotional state, which is then automatically recognized by emotion analysis software.

[0850] 2. Data transmission

[0851] Once the user enters the information, it is sent to the server in JSON format, allowing the server to parse and process the incoming data.

[0852] 3. Processing on the Server

[0853] The server does the following:

[0854] Extract user information: Extract user preference information, dietary restrictions, ingredient information, and emotional state from the received data.

[0855] Recipe filtering: Based on the extracted information, the database is filtered for suitable recipes, and sentiment analysis software is used to consider the user's emotional state and prioritize recipes that best fit their current emotions.

[0856] Random Selection: Randomly select one of the filtered recipes.

[0857] 4. Delivery options available

[0858] It suggests food delivery options related to the selected recipe, making it easy for users to get the ingredients they need.

[0859] 5. Return of Information

[0860] The selected recipe and delivery options are then sent back to the user's device in JSON format, where they are displayed to the user.

[0861] Hardware and software used

[0862] Hardware: User devices are smartphones, tablets, or PCs. Servers are high-performance computer systems.

[0863] Software: The front end is a smartphone application (iOS / Android), the back end is Python's Flask and PostgreSQL, and the sentiment analysis is performed using IBM Watson's sentiment analysis API.

[0864] Specific examples

[0865] For example, if user "user1" enters the following information:

[0866] Preferences: "Italian food" and "low carbohydrates"

[0867] Dietary Information: "Gluten Free"

[0868] Ingredients: "Tomato" "Chicken"

[0869] Emotional state: "Stress"

[0870] Based on this information, the server processes the data and selects an appropriate recipe, such as "Chicken Alfredo," along with delivery options for that related food. The selection is then sent back to the user's device, where the user can review and order delivery.

[0871] Prompt Sentence Examples

[0872] Preferences: "Italian food" and "low carbohydrates"

[0873] Dietary Information: "Gluten Free"

[0874] Ingredients: "Tomato" "Chicken"

[0875] Emotional state: "Stress"

[0876] Use this information to suggest the best recipes and delivery options.

[0877] As described above, the present invention can provide more accurate personalized recipes that take into account not only the user's preferences and dietary restrictions, but also their emotional state, and can also suggest delivery options to help them achieve these recipes.

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

[0879] Step 1:

[0880] User Input

[0881] Users use a dedicated application to input their preferences (e.g., Italian food, low carbohydrates), dietary restrictions (e.g., gluten-free), and ingredients (e.g., tomatoes, chicken). Furthermore, emotion analysis software collects the user's emotional state (e.g., stress) through the application.

[0882] Input: User preference information, dietary restriction information, ingredient information, emotional state

[0883] Output: Data collected by user devices

[0884] Step 2:

[0885] Data transmission

[0886] The device sends the collected user information to the server in JSON format.

[0887] Input: Data collected on the user device

[0888] Output: JSON data sent to the server

[0889] Step 3:

[0890] Extracting User Information

[0891] The server analyzes the received JSON data and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state.

[0892] Input: JSON data sent to the server

[0893] Output: Extracted user information

[0894] Step 4:

[0895] Recipe Filtering

[0896] The server filters the recipes in the database based on the extracted user information, specifically using emotion analysis software to prioritize recipes that are appropriate for the user's emotional state.

[0897] Input: Extracted user information

[0898] Data operations: filtering and prioritizing recipes in a database

[0899] Output: Filtered recipe list

[0900] Step 5:

[0901] Applying ingredient information

[0902] The server further performs additional filtering on the filtered recipe list, taking into account ingredient information possessed by the user.

[0903] Input: filtered recipe list, user ingredient information

[0904] Data processing: Selection of recipes that match the ingredient information

[0905] Output: Final filtered recipe list

[0906] Step 6:

[0907] Random Selection

[0908] The server then randomly selects one recipe from the final filtered list of recipes.

[0909] Input: Final filtered recipe list

[0910] Data calculation: Random selection

[0911] Output: Selected recipe

[0912] Step 7:

[0913] Delivery options

[0914] The server generates data suggesting related food delivery options based on the selected recipe.

[0915] Input: Selected recipe

[0916] Data processing: Searching and suggesting relevant food delivery options

[0917] Output: Delivery options list

[0918] Step 8:

[0919] Returning the results

[0920] The server returns the selected recipe and associated delivery options in JSON format to the user device.

[0921] Input: Selected recipe, delivery options list

[0922] Output: JSON data sent back to the user device

[0923] Step 9:

[0924] Displaying Information

[0925] The terminal parses the returned JSON data and displays the selected recipe and delivery options to the user.

[0926] Input: Returned JSON data

[0927] Output: What is displayed to the user

[0928] The above are the specific processing steps of the system for realizing the present invention.

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

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

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

[0932] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

[0944] 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."

[0945] The present invention relates to an online recipe creation system that enhances users' dining experiences. The system receives user preference information and dietary restriction information, and generates and serves appropriate recipes based on the information. It also allows filtering based on certain ingredient information and operates on a subscription basis.

[0946] A natural language description of the program's operation

[0947] User

[0948] First, users input their preferences (e.g., "Italian food," "low carbohydrates") and dietary restrictions (e.g., "gluten-free") into the system. Then, they log in and request a recipe. Users can also input specific ingredients they have on hand.

[0949] Terminal

[0950] The terminal (user's device) provides an interface for sending the user's input preference information, dietary restriction information, and ingredient information to the server. When the user presses the recipe generation button, the terminal sends this information to the server in JSON format.

[0951] server

[0952] The server receives the user information sent from the terminal and performs the following process.

[0953] 1. Extract user information:

[0954] The server extracts the user ID, preference information, dietary restriction information, and ingredient information from the received data.

[0955] 2. Filtering recipes:

[0956] The server filters all recipes in the database based on the user's preferences and dietary restrictions. For example, if a user selects "Italian" and "low carb" and specifies "gluten free" as a dietary restriction, only recipes that meet these criteria will be filtered.

[0957] 3. Considering ingredient information:

[0958] The server also takes into account the ingredient information entered by the user and performs further filtering. For example, if a user enters that they have "tomatoes" and "chicken," recipes containing these ingredients will be prioritized.

[0959] 4. Random recipe selection:

[0960] From the filtered recipes, the server randomly selects one recipe.

[0961] 5. Recipe provided:

[0962] The server returns the selected recipe to the terminal in JSON format.

[0963] Specific examples

[0964] For example, if user "user1" enters the following information:

[0965] Preferences: "Italian food" and "low carbohydrates"

[0966] Dietary Information: "Gluten Free"

[0967] Ingredients: "Tomato" "Chicken"

[0968] When the user presses the recipe generation button, the device sends this information to the server, which considers the user's preferences, dietary restrictions, and available ingredients to select an appropriate recipe, such as "Chicken Alfredo." The server then returns the recipe to the device, which displays it to the user.

[0969] This allows users to easily find suitable recipes based on their preferences, dietary restrictions, and available ingredients, allowing them to enjoy cooking. The system provides users with new cooking ideas and helps expand the variety of their meals.

[0970] The processing flow will be explained below.

[0971] Step 1:

[0972] The user logs into the platform and presses the recipe creation button.

[0973] Step 2:

[0974] The terminal displays an interface for inputting the user's preference information, dietary restriction information, and ingredient information.

[0975] Step 3:

[0976] The user inputs preference information (e.g., "Italian food," "low carbohydrate"), dietary restriction information (e.g., "gluten-free"), and ingredient information (e.g., "tomato," "chicken").

[0977] Step 4:

[0978] The device receives user input, converts it to JSON format, and sends it to the server.

[0979] Step 5:

[0980] The server processes the request received from the terminal and extracts the user ID, preference information, dietary restriction information, and ingredient information.

[0981] Step 6:

[0982] The server filters all recipes in the database based on the preference and dietary restriction information, selecting recipes that match the user's specified preferences and do not violate any dietary restrictions.

[0983] Step 7:

[0984] The server further filters the recipes based on the user's ingredient information, giving priority to recipes that include ingredients that the user owns.

[0985] Step 8:

[0986] The server randomly selects one recipe from the filtered list.

[0987] Step 9:

[0988] The server returns the selected recipe to the device in JSON format.

[0989] Step 10:

[0990] The terminal analyzes the recipe information received from the server and displays it on the user interface.

[0991] Step 11:

[0992] The user checks the presented recipe and enjoys cooking.

[0993] Example 1

[0994] 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."

[0995] Conventional recipe search systems have difficulty in considering detailed user preferences, dietary restrictions, and ingredients available on hand, making it difficult for users to quickly obtain the information they need. Furthermore, they do not adequately provide recipes that meet the individual needs of users, making it difficult to improve the variety and satisfaction of meals.

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

[0997] In this invention, the server includes means for receiving preference information and dietary restriction information from a user, means for filtering suitable recipes based on the preference information and dietary restriction information, means for receiving ingredient information from the user, means for filtering recipes taking the ingredient information into consideration, means for randomly selecting a recipe from the filtered recipes, means for providing the selected recipe to the user, means for the user to log in and transmit authentication information to the server, and means operated on a subscription basis for the user to periodically receive personalized recipes. This allows users to quickly obtain recipes based on their detailed preferences and restrictions, thereby improving the variety and satisfaction of their meals.

[0998] "User" refers to a person who uses the system and inputs information such as their preferences, dietary restrictions, and ingredients.

[0999] "Preference information" refers to information that serves as the basis for selecting a particular recipe, such as the user's type of cuisine and nutritional restrictions.

[1000] "Dietary restriction information" refers to information about a user's allergies or nutritional restrictions, such as information to avoid certain foods or ingredients.

[1001] "Ingredient information" refers to information about specific ingredients that the user already owns, and is taken into consideration when selecting a recipe.

[1002] "Filtering" refers to the process of sorting data based on specific conditions and extracting only the relevant items.

[1003] "Randomly select" means to randomly select one of the filtered items.

[1004] "Server" refers to a central computer system that processes information received from users and provides the necessary data.

[1005] A "terminal" is a device that allows a user to access a system and is responsible for input and display.

[1006] "Authentication information" is information used to verify a user's identity, and typically consists of a user ID and password.

[1007] "Subscription-based" refers to a method of using a service by paying a recurring fee, which allows users to receive personalized content on a regular basis.

[1008] "JSON format" is an abbreviation for JavaScript Object Notation, and refers to a lightweight data exchange format for describing data in a structured text format.

[1009] The present invention relates to an online recipe generation system that enhances a user's dining experience. The system receives a user's preference information and dietary restriction information, and generates and serves appropriate recipes based on that information. It can also provide more personalized recipes by taking into account specific ingredient information the user has.

[1010] User

[1011] First, a user enters their preferences (e.g., "Italian food," "low carbohydrates," etc.) and dietary restrictions (e.g., "gluten-free") into the system. Next, they log in to their account and request recipe generation. The user can also enter specific ingredient information (e.g., "tomato," "chicken," etc.) that they have on hand. This information is sent to the server via their terminal.

[1012] Terminal

[1013] The terminal (user's device) converts the user's input preferences, dietary restrictions, and ingredient information into JSON format and sends it to the server. The terminal also sends the user's login authentication information to the server. The filtered recipe is sent back to the terminal and displayed to the user.

[1014] server

[1015] When the server receives the user information sent from the device, it analyzes the JSON-formatted data and extracts preference information, dietary restriction information, and ingredient information. Based on this information, the server filters all recipes in the database. It then further filters the recipes taking into account ingredient information. From the recipes obtained as a result of the filtering, the server randomly selects one recipe and returns it to the device in JSON format.

[1016] Specific examples

[1017] For example, if user "user1" enters the following information:

[1018] Preferences: "Italian food" and "low carbohydrates"

[1019] Dietary Information: "Gluten Free"

[1020] Ingredients: "Tomato" "Chicken"

[1021] When the user presses the recipe generation button, the device sends this information to the server, which considers the user's preferences, dietary restrictions, and available ingredients to select an appropriate recipe, such as "Chicken Alfredo." The server then returns the recipe to the device, which displays it to the user.

[1022] Example prompt sentence:

[1023] Can you recommend some "Italian" and "low carb" recipes that are "gluten free" and contain "tomatoes" and "chicken"?

[1024] In this way, users can quickly obtain optimal recipes based on their own preferences and restrictions using ingredients they have on hand. This system provides users with new cooking ideas and improves the variety and satisfaction of their meals.

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

[1026] Step 1: The user logs into the system.

[1027] Input: User ID and password

[1028] Output: Authentication token

[1029] Specific operation: The user enters their user ID and password on the login screen and sends them to the terminal. The terminal then sends that information to the server. The server verifies the received information, and if the user is legitimate, generates an authentication token and sends it back to the terminal.

[1030] Step 2: The user inputs preference information, dietary restriction information, and ingredient information.

[1031] Input: Preference information (e.g., "Italian food" or "low carb"), dietary restriction information (e.g., "gluten-free"), ingredient information (e.g., "tomato" or "chicken")

[1032] Output: Request data in JSON format

[1033] Specific operation: The user inputs various information using a dedicated input interface, and the device converts this information into JSON format.

[1034] Step 3: The terminal transmits the user's input information to the server.

[1035] Input: Request data in JSON format

[1036] Output: Send data to the server

[1037] Specific operation: The device sends the user's preference information, dietary restriction information, and ingredient information in JSON format to the server. The sent data, including user authentication, is packetized and sent to the server.

[1038] Step 4: The server parses and extracts the user information.

[1039] Input: Request data in JSON format

[1040] Output: User, preferences, dietary restrictions, and ingredient information

[1041] Specific operation: The server parses the received JSON data and extracts the user ID, preference information, dietary restriction information, and ingredient information. This data is temporarily stored in the server's memory.

[1042] Step 5: The server filters the recipes based on the preference information and dietary restriction information.

[1043] Input: Preferences and dietary restrictions

[1044] Output: Filtered recipe list

[1045] What happens: The server filters all recipes in the database to find those that match the user's preferences and dietary restrictions. For example, it selects only "Italian," "low carb," and "gluten-free" recipes.

[1046] Step 6: The server further filters the recipes taking into account the ingredient information.

[1047] Input: filtered recipe list, ingredient information

[1048] Output: A list of recipes filtered by ingredients.

[1049] Specific operation: The server further filters the recipe list obtained from the first filtering, taking into account the ingredient information possessed by the user, and extracts only recipes that contain the relevant ingredients. For example, it extracts only recipes that contain "tomato" and "chicken."

[1050] Step 7: The server randomly selects a recipe from the filtered recipes.

[1051] Input: A list of recipes filtered by ingredients

[1052] Output: Selected recipes

[1053] Specific operation: The server randomly selects one recipe from the list of recipes obtained by the above filtering. This selection process is performed randomly using a random number generator or the like.

[1054] Step 8: The server returns the selected recipe to the terminal in JSON format.

[1055] Input: Selected recipe

[1056] Output: Recipe data in JSON format

[1057] What it does: The server converts a randomly selected recipe into JSON format and sends it to the device. The device receives the data and returns a confirmation to the server that it was received successfully.

[1058] Step 9: The terminal displays the received recipe to the user.

[1059] Input: Recipe data in JSON format

[1060] Output: The recipe displayed in the user interface

[1061] Specific operation: The device parses the received JSON data and extracts the recipe information. The extracted recipe information is displayed on the screen in a format that the user can view. This allows the user to view recipes based on their preferences and restrictions.

[1062] (Application example 1)

[1063] 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."

[1064] In conventional food delivery services, it is difficult for users to select appropriate dishes based on their preferences and dietary restrictions. In addition, due to the lack of a system to quickly find suitable recipes and dishes, users have to spend time searching for dishes that suit them. This makes it particularly difficult for users with specific dietary restrictions or preferences to choose a satisfying meal.

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

[1066] In this invention, the server includes means for receiving preference information and dietary restriction information from a user, means for filtering suitable dishes based on the preference information and dietary restriction information, means for suggesting appropriate dishes from among the filtered dishes, and means for providing the suggested dishes to the user and ordering the appropriate dishes, thereby enabling the user to easily select and quickly order the optimal dishes based on their preferences and dietary restrictions.

[1067] "User preference information" refers to information such as the type of food, seasoning, cooking method, etc. that the user prefers.

[1068] "Dietary restriction information" refers to information about ingredients or foods that a user should avoid, such as restrictions due to allergies, health conditions, or religious reasons.

[1069] "Filtering" refers to the process of narrowing down items in a database based on specific criteria.

[1070] "Means for suggesting appropriate dishes" refers to a function within the system for selecting and suggesting optimal dishes based on the user's preference information and dietary restriction information.

[1071] "Means for ordering food" refers to a function within the system for executing the process of ordering the food selected by the user from a food service provider.

[1072] The present invention relates to a system that suggests optimal dishes based on a user's preference information and dietary restriction information, and enables the user to order through a food delivery service.

[1073] To implement the invention, the following configurations and processes are included.

[1074] User

[1075] A user uses a smartphone app to input their preferences (e.g., Italian food, low carb, etc.) and dietary restrictions (e.g., gluten-free). This information is entered through the app's interface. Once the user confirms their order, this information is sent to the server through the app's interface. As a concrete example, suppose the user inputs "Italian food," "low carb," and "gluten-free."

[1076] Terminal

[1077] The terminal provides an interface for sending the user's preference information and dietary restriction information to the server. This interface has a mechanism for sending data to the server in JSON format, for example. When the user presses the order confirmation button, the terminal sends this information to the server.

[1078] server

[1079] The server processes the received user information and proposes the most suitable dish. Specifically, it performs the following process.

[1080] 1. Extract user information:

[1081] The server extracts the user ID, preference information, and dietary restriction information from the received data.

[1082] 2. Cuisine filtering:

[1083] The server filters all dishes in the food delivery service's database based on the user's preferences and dietary restrictions. For example, if the user selects "Italian," "low carb," and "gluten-free," only dishes that meet these criteria will be filtered.

[1084] 3. Food suggestions:

[1085] From the filtered dishes, the server suggests appropriate dishes and returns them to the terminal in JSON format.

[1086] 4. Manage your orders:

[1087] Once the user selects a suggested dish and confirms the order, the information is sent to the restaurant, and once the food is ready, the user is notified of delivery information.

[1088] Hardware and software used

[1089] The hardware used includes a standard smartphone and server. The software includes a smartphone application and a back-end system that implements a server-side recipe filtering algorithm. It also includes a part that calls a food delivery API to retrieve and select dish information.

[1090] Specific examples

[1091] For example, if user "user1" enters the following information:

[1092] Preferences: "Italian food" and "low carbohydrates"

[1093] Dietary Information: "Gluten Free"

[1094] When the user presses the order confirmation button, the device sends this information to the server. The server considers the user's preferences and dietary restrictions, suggests appropriate dishes, and sends them back to the device. Once the user selects the most suitable dish, they can confirm the order and the food will be delivered from the restaurant.

[1095] Prompt Sentence Examples

[1096] A user has entered their preferences (Italian, low carb) and dietary restrictions (gluten free). Using this information, use a food delivery API to suggest a list of dishes that would best suit the user.

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

[1098] Step 1:

[1099] Users use a smartphone app to input their preferences (e.g., Italian food, low carbohydrates, etc.) and dietary restrictions (e.g., gluten-free). This information is prepared as JSON-formatted data in the app's interface. Input: User preferences and dietary restrictions. Output: User information in JSON format.

[1100] Step 2:

[1101] The device sends the preference information and dietary restriction information entered by the user to the server. Specifically, when the user presses the order confirmation button, the device sends this information to the server via the in-app API. Input: User information in JSON format. Output: Information sent to the server.

[1102] Step 3:

[1103] The server processes the data received from the device and extracts the user ID, preference information, and dietary restriction information. Specifically, the server parses the received JSON data and stores the necessary information in variables. Input: User information in JSON format. Output: Extracted user information.

[1104] Step 4:

[1105] The server filters all dishes in the database based on the user's preferences and dietary restrictions. Specifically, it uses SQL queries to extract only the dishes that match the preferences and restrictions and stores them in a temporary database. Input: Extracted user information. Output: Filtered list of dishes.

[1106] Step 5:

[1107] The server then suggests appropriate dishes from the filtered list. Specifically, it sorts the filtered list of dishes using an algorithm and selects the most suitable dish. Input: Filtered list of dishes. Output: Suggested dishes.

[1108] Step 6:

[1109] The server returns the suggested dishes to the device in JSON format. Specifically, it converts the information about the selected dish into JSON format and sends it to the device via API. Input: Suggested dishes. Output: Dish information in JSON format.

[1110] Step 7:

[1111] The device displays the recipe information received from the server to the user, allowing the user to confirm the most suitable recipe. Specifically, it updates the app's UI and displays a list of suggested recipes. Input: JSON-formatted recipe information. Output: Display to the user.

[1112] Step 8:

[1113] The user finally selects the dish they wish to order from the suggested dishes and presses the order confirmation button. Specifically, the ID of the dish selected by the user is resent from the terminal to the server. Input: User's dish selection. Output: Information about the selected dish.

[1114] Step 9:

[1115] The server sends the order information for the dishes selected by the user to the restaurant. Specifically, the information about the selected dishes is sent to the restaurant using a food delivery API. Input: Information about the selected dishes. Output: Order information sent to the restaurant.

[1116] Step 10:

[1117] The restaurant prepares the ordered food and starts the delivery process. Specifically, it cooks the food according to the order information and hands it over to the delivery company. Input: Order information to the restaurant. Output: Prepared food and delivery information.

[1118] Step 11:

[1119] The terminal notifies the user of the progress of the delivery process. Specifically, progress information from the restaurant and delivery company is displayed in real time within the app. Input: Delivery information. Output: Notification to the user.

[1120] Step 12:

[1121] The user can receive the delivered food and enjoy the meal. Specifically, the user dines based on the provided food. Input: Delivered food. Output: User satisfaction.

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

[1123] The present invention relates to an online recipe creation system for enhancing a user's dining experience. This system receives user preference information, dietary restriction information, and ingredient information, and generates and provides recipes based on this information. In addition, by combining it with an emotion engine, it can provide personalized recipes that take the user's emotional state into consideration.

[1124] A natural language description of the program's operation

[1125] User

[1126] First, the user inputs their preferences (e.g., "Italian food," "low carbohydrates," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken") into the system. The system also recognizes the user's emotional state. Once the user logs in and presses the "Generate Recipe" button, this information is processed.

[1127] Terminal

[1128] The terminal (user's device) provides an interface to acquire user input and emotional state. When the user inputs information and presses the recipe generation button, the terminal sends this information in JSON format to the server.

[1129] server

[1130] The server receives the user information sent from the terminal and performs the following processing.

[1131] 1. Extract user information:

[1132] The server extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state from the received data.

[1133] 2. Filtering recipes:

[1134] The server filters all recipes in the database based on the user's preferences and dietary restrictions, selecting recipes that meet the user's specified criteria, and also considers the user's emotional state, prioritizing recipes that match the user's current emotions.

[1135] 3. Considering ingredient information:

[1136] The server then performs further filtering based on the user's ingredient information, giving priority to recipes that contain ingredients that the user owns.

[1137] 4. Use historical sentiment data:

[1138] The server also takes into account past emotion data stored by the emotion engine to select recipes to provide a consistent user experience.

[1139] 5. Random recipe selection:

[1140] From the filtered recipes, the server randomly selects one recipe.

[1141] 6. Recipe provided:

[1142] The selected recipe is returned to the terminal in JSON format.

[1143] Specific examples

[1144] For example, consider the case where user "user1" enters the following information and the emotion engine recognizes that the user is "feeling stressed":

[1145] Preferences: "Italian food" and "low carbohydrates"

[1146] Dietary Information: "Gluten Free"

[1147] Ingredients: "Tomato" "Chicken"

[1148] When the user presses the recipe generation button, the device sends this information to the server. The server then filters the information and prioritizes recipes that are expected to reduce the user's stress. In this case, an appropriate recipe that is expected to have a relaxing effect, such as "Chicken Alfredo," is selected as a candidate. The server then returns the final selected recipe to the device, which displays it to the user.

[1149] As described above, by taking into account the user's emotional state in addition to their preferences and dietary restrictions, more personalized recipes can be provided, enhancing the user's dining experience.

[1150] The processing flow will be explained below.

[1151] Step 1:

[1152] A user logs into the platform and enters preference information (e.g., "Italian food," "low carb"), dietary restriction information (e.g., "gluten-free"), and ingredient information (e.g., "tomato," "chicken").

[1153] Step 2:

[1154] The device receives user input, converts it into JSON format, and prepares it for sending to the emotion engine.

[1155] Step 3:

[1156] The emotion engine recognizes the user's emotional state in real time and analyzes the emotion the user is feeling (e.g., "stress").

[1157] Step 4:

[1158] The device sends the user's preference information, dietary restriction information, ingredient information, and emotional state from the emotion engine to the server in JSON format.

[1159] Step 5:

[1160] The server processes the request received from the terminal and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state.

[1161] Step 6:

[1162] The server filters all recipes in the database based on your preferences and dietary restrictions, for example, selecting recipes that meet the criteria "Italian," "low carb," and "gluten-free."

[1163] Step 7:

[1164] The server considers the user's emotional state and prioritizes recipes that suit that emotional state, for example, recipes that are suitable for "reducing stress."

[1165] Step 8:

[1166] The server then takes into account the user's ingredient information and filters recipes that include ingredients (e.g., "tomato" or "chicken") as final candidates.

[1167] Step 9:

[1168] The server randomly selects one recipe from the filtered list.

[1169] Step 10:

[1170] The server returns the selected recipe to the device in JSON format.

[1171] Step 11:

[1172] The terminal analyzes the recipe information received from the server and displays it on the user interface.

[1173] Step 12:

[1174] The user checks the presented recipe and enjoys cooking.

[1175] Example 2

[1176] 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."

[1177] Conventional recipe generation systems are limited in providing recipes based on user preferences and dietary restrictions, and do not provide recipes that take into account the emotional state of each user. Furthermore, recipes that take into account ingredient information are also lacking, making it difficult to efficiently use ingredients available to users. Therefore, there is a growing need for a system that can comprehensively improve users' dining experiences.

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

[1179] In this invention, the server includes a means for receiving preference information, dietary restriction information, and emotional information from the user, a means for filtering recipes based on the preference information, dietary restriction information, and emotional information, and a means for taking the user's ingredient information into account during the filtering process. This allows for the provision of personalized recipes that take into account not only the user's preferences and dietary restrictions, but also their emotional state. Furthermore, by incorporating the user's own ingredient information, the user can use ingredients more efficiently, improving the overall dining experience.

[1180] "Preference information" is data that represents the user's preferences for specific ingredients and cooking styles.

[1181] "Dietary restriction information" is data about ingredients and nutrients that a user wants to avoid for health reasons or personal preferences.

[1182] "Emotion information" is data that indicates the user's current emotional state, and includes states such as "stress," "joy," and "sadness," for example.

[1183] "Ingredient information" is data that indicates a list of ingredients that the user currently owns.

[1184] "Filtering" is the process of selecting information from a database that meets certain conditions based on information received from a user.

[1185] "Randomly selecting" means randomly selecting one of the filtered candidates without using any particular algorithm.

[1186] "Subscription-based" is a service format in which users pay a fixed fee to use the system on a regular basis.

[1187] A "personalized recipe" is a recipe that is specially created based on a user's preference information, dietary restriction information, emotional information, and ingredient information.

[1188] The present invention relates to an online recipe generation system for enhancing a user's dining experience, which receives user preference information, dietary restriction information, ingredient information, and emotional information, and generates and provides personalized recipes based on this information.

[1189] System configuration

[1190] User

[1191] Users input their preferences (e.g., "Italian food," "low carbohydrate," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken," etc.) into the system. Furthermore, the system recognizes their emotional state. This information is transmitted to the system via the user's device.

[1192] Terminal

[1193] The terminal (user's device) provides an interface to acquire user input and emotional state. When the user inputs information and presses the recipe generation button, the terminal sends this information in JSON format to the server.

[1194] server

[1195] The server receives the JSON data sent from the device and performs the following operations:

[1196] 1. Extract user information:

[1197] The server extracts the user ID, preference information, dietary restriction information, ingredient information, and emotion information from the received data.

[1198] 2. Filtering recipes:

[1199] The server filters all recipes in the database based on the user's preferences and dietary restrictions, and also takes into account the user's emotional state to prioritize recipes that are currently suitable for the user.

[1200] 3. Considering ingredient information:

[1201] The server further filters the recipes taking into account the ingredient information the user has.

[1202] 4. Use historical sentiment data:

[1203] The server references past emotion data stored by the emotion engine to assist in selecting recipes to provide a consistent user experience.

[1204] 5. Random recipe selection:

[1205] From the filtered recipes, the server randomly selects one recipe.

[1206] 6. Recipe provided:

[1207] The selected recipe is sent in JSON format to the terminal, which displays it to the user.

[1208] Specific examples

[1209] For example, consider the case where user "user1" enters the following information and the emotion engine recognizes that the user is "feeling stressed":

[1210] Preferences: "Italian food" and "low carbohydrates"

[1211] Dietary Information: "Gluten Free"

[1212] Ingredients: "Tomato" "Chicken"

[1213] When the user presses the recipe generation button, the device sends this information to the server. The server then filters the information and prioritizes recipes that are expected to reduce the user's stress. In this case, an appropriate recipe that is expected to have a relaxing effect, such as "Chicken Alfredo," is selected as a candidate. The server then returns the selected recipe in JSON format to the device, which then displays it to the user.

[1214] Example prompts for generative AI models

[1215] Examples of prompts for generative AI models include:

[1216] "Design a system that generates personalized recipes based on a user's preferences, dietary restrictions, and ingredients. Also consider the user's emotional state."

[1217] Includes:

[1218] The system can improve a user's overall dining experience by providing more personalized recipes based on the user's individual needs.

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

[1220] Step 1:

[1221] Entering user information

[1222] Users input their preferences (e.g., "Italian food," "low carbohydrates," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken," etc.) into the terminal. The system also recognizes the user's emotional state.

[1223] Input: User preferences, dietary restrictions, ingredients, and emotional state

[1224] Output: Data summarizing the information entered by the user

[1225] What it does: The user enters information into an application form and uses facial expression analysis cameras and other features to automatically recognize emotional states.

[1226] Step 2:

[1227] Sending information

[1228] When the user presses the recipe generation button, the terminal converts the entered information into JSON format and sends it to the server.

[1229] Input: User-entered preferences, dietary restrictions, ingredients, and emotional state

[1230] Output: User information converted to JSON format

[1231] Specific behavior: Converts data collected from the input form into JSON format and sends it to the server as an HTTP POST request.

[1232] Step 3:

[1233] Receiving and extracting user information

[1234] The server receives the JSON data sent from the device and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional information.

[1235] Input: JSON data sent from the terminal

[1236] Output: Extracted user ID, preference information, dietary restriction information, ingredient information, and emotional information

[1237] Specific behavior: The server's API endpoint parses the JSON data and stores each item in a variable.

[1238] Step 4:

[1239] Initial filtering of recipes

[1240] The server filters the recipes in the database based on the user's preference and dietary restriction information.

[1241] Input: User preferences and dietary restrictions

[1242] Output: Filtered recipe list

[1243] What it does: Extracts recipes that match the preferences and dietary restrictions using a database query (e.g., SQL query).

[1244] Step 5:

[1245] Considering emotional states

[1246] The server prioritizes recipes that are appropriate for the user's emotions from among the recipes filtered based on the emotional state.

[1247] Input: User's emotional information

[1248] Output: A list of recipes further refined based on emotional state

[1249] What it does: Calls the emotion engine, tags recipes related to the emotional state, and adds them to the filtering criteria.

[1250] Step 6:

[1251] Consideration of ingredient information

[1252] The server further filters the recipes taking into account the ingredient information the user has.

[1253] Input: User's ingredient information

[1254] Output: A list of recipes using ingredients you have

[1255] What it does: Re-filter the database for matching recipes based on the ingredients.

[1256] Step 7:

[1257] Use of past emotion data

[1258] The server references previously collected emotion data and integrates it into the current filtering conditions.

[1259] Input: Historical emotion data

[1260] Output: A comprehensive recipe list that also takes into account sentiment data

[1261] What it does: It retrieves past emotion data from the emotion engine via a database query and integrates it into the current recipe selection.

[1262] Step 8:

[1263] Random recipe selection

[1264] The server randomly selects one recipe from the filtered list.

[1265] Input: Filtered recipe list

[1266] Output: A randomly selected recipe

[1267] What it does: Uses a random function to randomly select one recipe from the filtered list of recipes.

[1268] Step 9:

[1269] Recipe provided

[1270] The selected recipe is sent in JSON format to the terminal, which displays it to the user.

[1271] Input: A randomly selected recipe

[1272] Output: The recipe displayed to the user

[1273] Specific operation: Recipe information is converted into JSON format and sent to the terminal as an HTTP response, and the terminal displays the information to the user.

[1274] (Application example 2)

[1275] 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."

[1276] Conventional recipe generation systems suggest recipes based on basic information such as user preferences and dietary restrictions, but do not consider the user's emotional state. As a result, it is difficult to suggest recipes that are in line with the user's mood and emotions on that day. Furthermore, even if a recipe is suggested, there is no mechanism to provide related food delivery options, which means that it is not possible to reduce the effort required for actual meal preparation.

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

[1278] In this invention, the server comprises: means for recognizing the emotional state of the user and filtering recipes based on the emotional state;

[1279] means for receiving preference information and dietary restriction information from a user;

[1280] a means for randomly selecting a recipe from among the filtered recipes;

[1281] Includes:

[1282] This allows recipe suggestions to be tailored not only to a user's preferences but also to their emotional state. Furthermore, by including a means for providing delivery options for related foods, users can easily obtain the foods they need and reduce the effort required for meal preparation. Furthermore, by including a means for performing sentiment analysis using a generative AI model, advanced sentiment recognition becomes possible, resulting in more accurate and personalized recipe suggestions.

[1283] "User" refers to an individual who utilizes the system to receive recipes.

[1284] "Preference information" refers to information about the types of dishes and ingredients that a user particularly likes.

[1285] "Dietary restriction information" refers to information about ingredients and dishes that users should avoid for health or religious reasons.

[1286] "Ingredient information" refers to information about ingredients currently in the user's possession.

[1287] "Emotional state" refers to information about a user's current mood or emotions.

[1288] "Emotion analysis" refers to the technology of analyzing a user's emotional state.

[1289] A "recipe" refers to a list of instructions and ingredients for making a particular dish.

[1290] "Filtering" refers to the process of narrowing down options based on specific criteria.

[1291] "Generative AI model" refers to a mathematical model for generating data using artificial intelligence.

[1292] "Server" refers to a computer system that processes information received from users and generates and serves recipes.

[1293] "Delivery Option" refers to an option that provides a service to deliver related food based on a recipe selected by a user.

[1294] MODE FOR CARRYING OUT THE INVENTION

[1295] The present invention is a system that generates personalized recipes based on a user's preferences, dietary restrictions, available ingredients, and emotional state, and also suggests related delivery options. Specific embodiments of the present invention will be described.

[1296] System configuration

[1297] The system of the present invention comprises the following main components:

[1298] 1. User Device: A device used by a user to access the system, including a smartphone, tablet, or PC. The user device provides an interface for inputting user preference information, dietary restriction information, ingredient information, and emotional state.

[1299] 2. Server: A central computer system that receives and processes information sent from user devices. The server performs recipe filtering, sentiment analysis, and delivery option suggestions.

[1300] 3. Sentiment Analysis Software: Software for analyzing the user's emotional state. It can use IBM Watson's sentiment analysis API or other generative AI models.

[1301] System Operation

[1302] 1. User Input

[1303] Using a device with a dedicated application installed, users input their preferences, dietary restrictions, ingredients, and emotional state, which is then automatically recognized by emotion analysis software.

[1304] 2. Data transmission

[1305] Once the user enters the information, it is sent to the server in JSON format, allowing the server to parse and process the incoming data.

[1306] 3. Processing on the Server

[1307] The server does the following:

[1308] Extract user information: Extract user preference information, dietary restrictions, ingredient information, and emotional state from the received data.

[1309] Recipe filtering: Based on the extracted information, the database is filtered for suitable recipes, and sentiment analysis software is used to consider the user's emotional state and prioritize recipes that best fit their current emotions.

[1310] Random Selection: Randomly select one of the filtered recipes.

[1311] 4. Delivery options available

[1312] It suggests food delivery options related to the selected recipe, making it easy for users to get the ingredients they need.

[1313] 5. Return of Information

[1314] The selected recipe and delivery options are then sent back to the user's device in JSON format, where they are displayed to the user.

[1315] Hardware and software used

[1316] Hardware: User devices are smartphones, tablets, or PCs. Servers are high-performance computer systems.

[1317] Software: The front end is a smartphone application (iOS / Android), the back end is Python's Flask and PostgreSQL, and the sentiment analysis is performed using IBM Watson's sentiment analysis API.

[1318] Specific examples

[1319] For example, if user "user1" enters the following information:

[1320] Preferences: "Italian food" and "low carbohydrates"

[1321] Dietary Information: "Gluten Free"

[1322] Ingredients: "Tomato" "Chicken"

[1323] Emotional state: "Stress"

[1324] Based on this information, the server processes the data and selects an appropriate recipe, such as "Chicken Alfredo," along with delivery options for that related food. The selection is then sent back to the user's device, where the user can review and order delivery.

[1325] Prompt Sentence Examples

[1326] Preferences: "Italian food" and "low carbohydrates"

[1327] Dietary Information: "Gluten Free"

[1328] Ingredients: "Tomato" "Chicken"

[1329] Emotional state: "Stress"

[1330] Use this information to suggest the best recipes and delivery options.

[1331] As described above, the present invention can provide more accurate personalized recipes that take into account not only the user's preferences and dietary restrictions, but also their emotional state, and can also suggest delivery options to help them achieve these recipes.

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

[1333] Step 1:

[1334] User Input

[1335] Users use a dedicated application to input their preferences (e.g., Italian food, low carbohydrates), dietary restrictions (e.g., gluten-free), and ingredients (e.g., tomatoes, chicken). Furthermore, emotion analysis software collects the user's emotional state (e.g., stress) through the application.

[1336] Input: User preference information, dietary restriction information, ingredient information, emotional state

[1337] Output: Data collected by user devices

[1338] Step 2:

[1339] Data transmission

[1340] The device sends the collected user information to the server in JSON format.

[1341] Input: Data collected on the user device

[1342] Output: JSON data sent to the server

[1343] Step 3:

[1344] Extracting User Information

[1345] The server analyzes the received JSON data and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state.

[1346] Input: JSON data sent to the server

[1347] Output: Extracted user information

[1348] Step 4:

[1349] Recipe Filtering

[1350] The server filters the recipes in the database based on the extracted user information, specifically using emotion analysis software to prioritize recipes that are appropriate for the user's emotional state.

[1351] Input: Extracted user information

[1352] Data operations: filtering and prioritizing recipes in a database

[1353] Output: Filtered recipe list

[1354] Step 5:

[1355] Applying ingredient information

[1356] The server further performs additional filtering on the filtered recipe list, taking into account ingredient information possessed by the user.

[1357] Input: filtered recipe list, user ingredient information

[1358] Data processing: Selection of recipes that match the ingredient information

[1359] Output: Final filtered recipe list

[1360] Step 6:

[1361] Random Selection

[1362] The server then randomly selects one recipe from the final filtered list of recipes.

[1363] Input: Final filtered recipe list

[1364] Data calculation: Random selection

[1365] Output: Selected recipe

[1366] Step 7:

[1367] Delivery options

[1368] The server generates data suggesting related food delivery options based on the selected recipe.

[1369] Input: Selected recipe

[1370] Data processing: Searching and suggesting relevant food delivery options

[1371] Output: Delivery options list

[1372] Step 8:

[1373] Returning the results

[1374] The server returns the selected recipe and associated delivery options in JSON format to the user device.

[1375] Input: Selected recipe, delivery options list

[1376] Output: JSON data sent back to the user device

[1377] Step 9:

[1378] Displaying Information

[1379] The terminal parses the returned JSON data and displays the selected recipe and delivery options to the user.

[1380] Input: Returned JSON data

[1381] Output: What is displayed to the user

[1382] The above are the specific processing steps of the system for realizing the present invention.

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

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

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

[1386] [Fourth embodiment]

[1387] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

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

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

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

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

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

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

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

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

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

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

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

[1399] 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."

[1400] The present invention relates to an online recipe creation system that enhances users' dining experiences. The system receives user preference information and dietary restriction information, and generates and serves appropriate recipes based on the information. It also allows filtering based on certain ingredient information and operates on a subscription basis.

[1401] A natural language description of the program's operation

[1402] User

[1403] First, users input their preferences (e.g., "Italian food," "low carbohydrates") and dietary restrictions (e.g., "gluten-free") into the system. Then, they log in and request a recipe. Users can also input specific ingredients they have on hand.

[1404] Terminal

[1405] The terminal (user's device) provides an interface for sending the user's input preference information, dietary restriction information, and ingredient information to the server. When the user presses the recipe generation button, the terminal sends this information to the server in JSON format.

[1406] server

[1407] The server receives the user information sent from the terminal and performs the following process.

[1408] 1. Extract user information:

[1409] The server extracts the user ID, preference information, dietary restriction information, and ingredient information from the received data.

[1410] 2. Filtering recipes:

[1411] The server filters all recipes in the database based on the user's preferences and dietary restrictions. For example, if a user selects "Italian" and "low carb" and specifies "gluten free" as a dietary restriction, only recipes that meet these criteria will be filtered.

[1412] 3. Considering ingredient information:

[1413] The server also takes into account the ingredient information entered by the user and performs further filtering. For example, if a user enters that they have "tomatoes" and "chicken," recipes containing these ingredients will be prioritized.

[1414] 4. Random recipe selection:

[1415] From the filtered recipes, the server randomly selects one recipe.

[1416] 5. Recipe provided:

[1417] The server returns the selected recipe to the terminal in JSON format.

[1418] Specific examples

[1419] For example, if user "user1" enters the following information:

[1420] Preferences: "Italian food" and "low carbohydrates"

[1421] Dietary Information: "Gluten Free"

[1422] Ingredients: "Tomato" "Chicken"

[1423] When the user presses the recipe generation button, the device sends this information to the server, which considers the user's preferences, dietary restrictions, and available ingredients to select an appropriate recipe, such as "Chicken Alfredo." The server then returns the recipe to the device, which displays it to the user.

[1424] This allows users to easily find suitable recipes based on their preferences, dietary restrictions, and available ingredients, allowing them to enjoy cooking. The system provides users with new cooking ideas and helps expand the variety of their meals.

[1425] The processing flow will be explained below.

[1426] Step 1:

[1427] The user logs into the platform and presses the recipe creation button.

[1428] Step 2:

[1429] The terminal displays an interface for inputting the user's preference information, dietary restriction information, and ingredient information.

[1430] Step 3:

[1431] The user inputs preference information (e.g., "Italian food," "low carbohydrate"), dietary restriction information (e.g., "gluten-free"), and ingredient information (e.g., "tomato," "chicken").

[1432] Step 4:

[1433] The device receives user input, converts it to JSON format, and sends it to the server.

[1434] Step 5:

[1435] The server processes the request received from the terminal and extracts the user ID, preference information, dietary restriction information, and ingredient information.

[1436] Step 6:

[1437] The server filters all recipes in the database based on the preference and dietary restriction information, selecting recipes that match the user's specified preferences and do not violate any dietary restrictions.

[1438] Step 7:

[1439] The server further filters the recipes based on the user's ingredient information, giving priority to recipes that include ingredients that the user owns.

[1440] Step 8:

[1441] The server randomly selects one recipe from the filtered list.

[1442] Step 9:

[1443] The server returns the selected recipe to the device in JSON format.

[1444] Step 10:

[1445] The terminal analyzes the recipe information received from the server and displays it on the user interface.

[1446] Step 11:

[1447] The user checks the presented recipe and enjoys cooking.

[1448] Example 1

[1449] 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."

[1450] Conventional recipe search systems have difficulty in considering detailed user preferences, dietary restrictions, and ingredients available on hand, making it difficult for users to quickly obtain the information they need. Furthermore, they do not adequately provide recipes that meet the individual needs of users, making it difficult to improve the variety and satisfaction of meals.

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

[1452] In this invention, the server includes means for receiving preference information and dietary restriction information from a user, means for filtering suitable recipes based on the preference information and dietary restriction information, means for receiving ingredient information from the user, means for filtering recipes taking the ingredient information into consideration, means for randomly selecting a recipe from the filtered recipes, means for providing the selected recipe to the user, means for the user to log in and transmit authentication information to the server, and means operated on a subscription basis for the user to periodically receive personalized recipes. This allows users to quickly obtain recipes based on their detailed preferences and restrictions, thereby improving the variety and satisfaction of their meals.

[1453] "User" refers to a person who uses the system and inputs information such as their preferences, dietary restrictions, and ingredients.

[1454] "Preference information" refers to information that serves as the basis for selecting a particular recipe, such as the user's type of cuisine and nutritional restrictions.

[1455] "Dietary restriction information" refers to information about a user's allergies or nutritional restrictions, such as information to avoid certain foods or ingredients.

[1456] "Ingredient information" refers to information about specific ingredients that the user already owns, and is taken into consideration when selecting a recipe.

[1457] "Filtering" refers to the process of sorting data based on specific conditions and extracting only the relevant items.

[1458] "Randomly select" means to randomly select one of the filtered items.

[1459] "Server" refers to a central computer system that processes information received from users and provides the necessary data.

[1460] A "terminal" is a device that allows a user to access a system and is responsible for input and display.

[1461] "Authentication information" is information used to verify a user's identity, and typically consists of a user ID and password.

[1462] "Subscription-based" refers to a method of using a service by paying a recurring fee, which allows users to receive personalized content on a regular basis.

[1463] "JSON format" is an abbreviation for JavaScript Object Notation, and refers to a lightweight data exchange format for describing data in a structured text format.

[1464] The present invention relates to an online recipe generation system that enhances a user's dining experience. The system receives a user's preference information and dietary restriction information, and generates and serves appropriate recipes based on that information. It can also provide more personalized recipes by taking into account specific ingredient information the user has.

[1465] User

[1466] First, a user enters their preferences (e.g., "Italian food," "low carbohydrates," etc.) and dietary restrictions (e.g., "gluten-free") into the system. Next, they log in to their account and request recipe generation. The user can also enter specific ingredient information (e.g., "tomato," "chicken," etc.) that they have on hand. This information is sent to the server via their terminal.

[1467] Terminal

[1468] The terminal (user's device) converts the user's input preferences, dietary restrictions, and ingredient information into JSON format and sends it to the server. The terminal also sends the user's login authentication information to the server. The filtered recipe is sent back to the terminal and displayed to the user.

[1469] server

[1470] When the server receives the user information sent from the device, it analyzes the JSON-formatted data and extracts preference information, dietary restriction information, and ingredient information. Based on this information, the server filters all recipes in the database. It then further filters the recipes taking into account ingredient information. From the recipes obtained as a result of the filtering, the server randomly selects one recipe and returns it to the device in JSON format.

[1471] Specific examples

[1472] For example, if user "user1" enters the following information:

[1473] Preferences: "Italian food" and "low carbohydrates"

[1474] Dietary Information: "Gluten Free"

[1475] Ingredients: "Tomato" "Chicken"

[1476] When the user presses the recipe generation button, the device sends this information to the server, which considers the user's preferences, dietary restrictions, and available ingredients to select an appropriate recipe, such as "Chicken Alfredo." The server then returns the recipe to the device, which displays it to the user.

[1477] Example prompt sentence:

[1478] Can you recommend some "Italian" and "low carb" recipes that are "gluten free" and contain "tomatoes" and "chicken"?

[1479] In this way, users can quickly obtain optimal recipes based on their own preferences and restrictions using ingredients they have on hand. This system provides users with new cooking ideas and improves the variety and satisfaction of their meals.

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

[1481] Step 1: The user logs into the system.

[1482] Input: User ID and password

[1483] Output: Authentication token

[1484] Specific operation: The user enters their user ID and password on the login screen and sends them to the terminal. The terminal then sends that information to the server. The server verifies the received information, and if the user is legitimate, generates an authentication token and sends it back to the terminal.

[1485] Step 2: The user inputs preference information, dietary restriction information, and ingredient information.

[1486] Input: Preference information (e.g., "Italian food" or "low carb"), dietary restriction information (e.g., "gluten-free"), ingredient information (e.g., "tomato" or "chicken")

[1487] Output: Request data in JSON format

[1488] Specific operation: The user inputs various information using a dedicated input interface, and the device converts this information into JSON format.

[1489] Step 3: The terminal transmits the user's input information to the server.

[1490] Input: Request data in JSON format

[1491] Output: Send data to the server

[1492] Specific operation: The device sends the user's preference information, dietary restriction information, and ingredient information in JSON format to the server. The sent data, including user authentication, is packetized and sent to the server.

[1493] Step 4: The server parses and extracts the user information.

[1494] Input: Request data in JSON format

[1495] Output: User, preferences, dietary restrictions, and ingredient information

[1496] Specific operation: The server parses the received JSON data and extracts the user ID, preference information, dietary restriction information, and ingredient information. This data is temporarily stored in the server's memory.

[1497] Step 5: The server filters the recipes based on the preference information and dietary restriction information.

[1498] Input: Preferences and dietary restrictions

[1499] Output: Filtered recipe list

[1500] What happens: The server filters all recipes in the database to find those that match the user's preferences and dietary restrictions. For example, it selects only "Italian," "low carb," and "gluten-free" recipes.

[1501] Step 6: The server further filters the recipes taking into account the ingredient information.

[1502] Input: filtered recipe list, ingredient information

[1503] Output: A list of recipes filtered by ingredients.

[1504] Specific operation: The server further filters the recipe list obtained from the first filtering, taking into account the ingredient information possessed by the user, and extracts only recipes that contain the relevant ingredients. For example, it extracts only recipes that contain "tomato" and "chicken."

[1505] Step 7: The server randomly selects a recipe from the filtered recipes.

[1506] Input: A list of recipes filtered by ingredients

[1507] Output: Selected recipes

[1508] Specific operation: The server randomly selects one recipe from the list of recipes obtained by the above filtering. This selection process is performed randomly using a random number generator or the like.

[1509] Step 8: The server returns the selected recipe to the terminal in JSON format.

[1510] Input: Selected recipe

[1511] Output: Recipe data in JSON format

[1512] What it does: The server converts a randomly selected recipe into JSON format and sends it to the device. The device receives the data and returns a confirmation to the server that it was received successfully.

[1513] Step 9: The terminal displays the received recipe to the user.

[1514] Input: Recipe data in JSON format

[1515] Output: The recipe displayed in the user interface

[1516] Specific operation: The device parses the received JSON data and extracts the recipe information. The extracted recipe information is displayed on the screen in a format that the user can view. This allows the user to view recipes based on their preferences and restrictions.

[1517] (Application example 1)

[1518] 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."

[1519] In conventional food delivery services, it is difficult for users to select appropriate dishes based on their preferences and dietary restrictions. In addition, due to the lack of a system to quickly find suitable recipes and dishes, users have to spend time searching for dishes that suit them. This makes it particularly difficult for users with specific dietary restrictions or preferences to choose a satisfying meal.

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

[1521] In this invention, the server includes means for receiving preference information and dietary restriction information from a user, means for filtering suitable dishes based on the preference information and dietary restriction information, means for suggesting appropriate dishes from among the filtered dishes, and means for providing the suggested dishes to the user and ordering the appropriate dishes, thereby enabling the user to easily select and quickly order the optimal dishes based on their preferences and dietary restrictions.

[1522] "User preference information" refers to information such as the type of food, seasoning, cooking method, etc. that the user prefers.

[1523] "Dietary restriction information" refers to information about ingredients or foods that a user should avoid, such as restrictions due to allergies, health conditions, or religious reasons.

[1524] "Filtering" refers to the process of narrowing down items in a database based on specific criteria.

[1525] "Means for suggesting appropriate dishes" refers to a function within the system for selecting and suggesting optimal dishes based on the user's preference information and dietary restriction information.

[1526] "Means for ordering food" refers to a function within the system for executing the process of ordering the food selected by the user from a food service provider.

[1527] The present invention relates to a system that suggests optimal dishes based on a user's preference information and dietary restriction information, and enables the user to order through a food delivery service.

[1528] To implement the invention, the following configurations and processes are included.

[1529] User

[1530] A user uses a smartphone app to input their preferences (e.g., Italian food, low carb, etc.) and dietary restrictions (e.g., gluten-free). This information is entered through the app's interface. Once the user confirms their order, this information is sent to the server through the app's interface. As a concrete example, suppose the user inputs "Italian food," "low carb," and "gluten-free."

[1531] Terminal

[1532] The terminal provides an interface for sending the user's preference information and dietary restriction information to the server. This interface has a mechanism for sending data to the server in JSON format, for example. When the user presses the order confirmation button, the terminal sends this information to the server.

[1533] server

[1534] The server processes the received user information and proposes the most suitable dish. Specifically, it performs the following process.

[1535] 1. Extract user information:

[1536] The server extracts the user ID, preference information, and dietary restriction information from the received data.

[1537] 2. Cuisine filtering:

[1538] The server filters all dishes in the food delivery service's database based on the user's preferences and dietary restrictions. For example, if the user selects "Italian," "low carb," and "gluten-free," only dishes that meet these criteria will be filtered.

[1539] 3. Food suggestions:

[1540] From the filtered dishes, the server suggests appropriate dishes and returns them to the terminal in JSON format.

[1541] 4. Manage your orders:

[1542] Once the user selects a suggested dish and confirms the order, the information is sent to the restaurant, and once the food is ready, the user is notified of delivery information.

[1543] Hardware and software used

[1544] The hardware used includes a standard smartphone and server. The software includes a smartphone application and a back-end system that implements a server-side recipe filtering algorithm. It also includes a part that calls a food delivery API to retrieve and select dish information.

[1545] Specific examples

[1546] For example, if user "user1" enters the following information:

[1547] Preferences: "Italian food" and "low carbohydrates"

[1548] Dietary Information: "Gluten Free"

[1549] When the user presses the order confirmation button, the device sends this information to the server. The server considers the user's preferences and dietary restrictions, suggests appropriate dishes, and sends them back to the device. Once the user selects the most suitable dish, they can confirm the order and the food will be delivered from the restaurant.

[1550] Prompt Sentence Examples

[1551] A user has entered their preferences (Italian, low carb) and dietary restrictions (gluten free). Using this information, use a food delivery API to suggest a list of dishes that would best suit the user.

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

[1553] Step 1:

[1554] Users use a smartphone app to input their preferences (e.g., Italian food, low carbohydrates, etc.) and dietary restrictions (e.g., gluten-free). This information is prepared as JSON-formatted data in the app's interface. Input: User preferences and dietary restrictions. Output: User information in JSON format.

[1555] Step 2:

[1556] The device sends the preference information and dietary restriction information entered by the user to the server. Specifically, when the user presses the order confirmation button, the device sends this information to the server via the in-app API. Input: User information in JSON format. Output: Information sent to the server.

[1557] Step 3:

[1558] The server processes the data received from the device and extracts the user ID, preference information, and dietary restriction information. Specifically, the server parses the received JSON data and stores the necessary information in variables. Input: User information in JSON format. Output: Extracted user information.

[1559] Step 4:

[1560] The server filters all dishes in the database based on the user's preferences and dietary restrictions. Specifically, it uses SQL queries to extract only the dishes that match the preferences and restrictions and stores them in a temporary database. Input: Extracted user information. Output: Filtered list of dishes.

[1561] Step 5:

[1562] The server then suggests appropriate dishes from the filtered list. Specifically, it sorts the filtered list of dishes using an algorithm and selects the most suitable dish. Input: Filtered list of dishes. Output: Suggested dishes.

[1563] Step 6:

[1564] The server returns the suggested dishes to the device in JSON format. Specifically, it converts the information about the selected dish into JSON format and sends it to the device via API. Input: Suggested dishes. Output: Dish information in JSON format.

[1565] Step 7:

[1566] The device displays the recipe information received from the server to the user, allowing the user to confirm the most suitable recipe. Specifically, it updates the app's UI and displays a list of suggested recipes. Input: JSON-formatted recipe information. Output: Display to the user.

[1567] Step 8:

[1568] The user finally selects the dish they wish to order from the suggested dishes and presses the order confirmation button. Specifically, the ID of the dish selected by the user is resent from the terminal to the server. Input: User's dish selection. Output: Information about the selected dish.

[1569] Step 9:

[1570] The server sends the order information for the dishes selected by the user to the restaurant. Specifically, the information about the selected dishes is sent to the restaurant using a food delivery API. Input: Information about the selected dishes. Output: Order information sent to the restaurant.

[1571] Step 10:

[1572] The restaurant prepares the ordered food and starts the delivery process. Specifically, it cooks the food according to the order information and hands it over to the delivery company. Input: Order information to the restaurant. Output: Prepared food and delivery information.

[1573] Step 11:

[1574] The terminal notifies the user of the progress of the delivery process. Specifically, progress information from the restaurant and delivery company is displayed in real time within the app. Input: Delivery information. Output: Notification to the user.

[1575] Step 12:

[1576] The user can receive the delivered food and enjoy the meal. Specifically, the user dines based on the provided food. Input: Delivered food. Output: User satisfaction.

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

[1578] The present invention relates to an online recipe creation system for enhancing a user's dining experience. This system receives user preference information, dietary restriction information, and ingredient information, and generates and provides recipes based on this information. In addition, by combining it with an emotion engine, it can provide personalized recipes that take the user's emotional state into consideration.

[1579] A natural language description of the program's operation

[1580] User

[1581] First, the user inputs their preferences (e.g., "Italian food," "low carbohydrates," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken") into the system. The system also recognizes the user's emotional state. Once the user logs in and presses the "Generate Recipe" button, this information is processed.

[1582] Terminal

[1583] The terminal (user's device) provides an interface to acquire user input and emotional state. When the user inputs information and presses the recipe generation button, the terminal sends this information in JSON format to the server.

[1584] server

[1585] The server receives the user information sent from the terminal and performs the following processing.

[1586] 1. Extract user information:

[1587] The server extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state from the received data.

[1588] 2. Filtering recipes:

[1589] The server filters all recipes in the database based on the user's preferences and dietary restrictions, selecting recipes that meet the user's specified criteria, and also considers the user's emotional state, prioritizing recipes that match the user's current emotions.

[1590] 3. Considering ingredient information:

[1591] The server then performs further filtering based on the user's ingredient information, giving priority to recipes that contain ingredients that the user owns.

[1592] 4. Use historical sentiment data:

[1593] The server also takes into account past emotion data stored by the emotion engine to select recipes to provide a consistent user experience.

[1594] 5. Random recipe selection:

[1595] From the filtered recipes, the server randomly selects one recipe.

[1596] 6. Recipe provided:

[1597] The selected recipe is returned to the terminal in JSON format.

[1598] Specific examples

[1599] For example, consider the case where user "user1" enters the following information and the emotion engine recognizes that the user is "feeling stressed":

[1600] Preferences: "Italian food" and "low carbohydrates"

[1601] Dietary Information: "Gluten Free"

[1602] Ingredients: "Tomato" "Chicken"

[1603] When the user presses the recipe generation button, the device sends this information to the server. The server then filters the information and prioritizes recipes that are expected to reduce the user's stress. In this case, an appropriate recipe that is expected to have a relaxing effect, such as "Chicken Alfredo," is selected as a candidate. The server then returns the final selected recipe to the device, which displays it to the user.

[1604] As described above, by taking into account the user's emotional state in addition to their preferences and dietary restrictions, more personalized recipes can be provided, enhancing the user's dining experience.

[1605] The processing flow will be explained below.

[1606] Step 1:

[1607] A user logs into the platform and enters preference information (e.g., "Italian food," "low carb"), dietary restriction information (e.g., "gluten-free"), and ingredient information (e.g., "tomato," "chicken").

[1608] Step 2:

[1609] The device receives user input, converts it into JSON format, and prepares it for sending to the emotion engine.

[1610] Step 3:

[1611] The emotion engine recognizes the user's emotional state in real time and analyzes the emotion the user is feeling (e.g., "stress").

[1612] Step 4:

[1613] The device sends the user's preference information, dietary restriction information, ingredient information, and emotional state from the emotion engine to the server in JSON format.

[1614] Step 5:

[1615] The server processes the request received from the terminal and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state.

[1616] Step 6:

[1617] The server filters all recipes in the database based on your preferences and dietary restrictions, for example, selecting recipes that meet the criteria "Italian," "low carb," and "gluten-free."

[1618] Step 7:

[1619] The server considers the user's emotional state and prioritizes recipes that suit that emotional state, for example, recipes that are suitable for "reducing stress."

[1620] Step 8:

[1621] The server then takes into account the user's ingredient information and filters recipes that include ingredients (e.g., "tomato" or "chicken") as final candidates.

[1622] Step 9:

[1623] The server randomly selects one recipe from the filtered list.

[1624] Step 10:

[1625] The server returns the selected recipe to the device in JSON format.

[1626] Step 11:

[1627] The terminal analyzes the recipe information received from the server and displays it on the user interface.

[1628] Step 12:

[1629] The user checks the presented recipe and enjoys cooking.

[1630] Example 2

[1631] 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."

[1632] Conventional recipe generation systems are limited in providing recipes based on user preferences and dietary restrictions, and do not provide recipes that take into account the emotional state of each user. Furthermore, recipes that take into account ingredient information are also lacking, making it difficult to efficiently use ingredients available to users. Therefore, there is a growing need for a system that can comprehensively improve users' dining experiences.

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

[1634] In this invention, the server includes a means for receiving preference information, dietary restriction information, and emotional information from the user, a means for filtering recipes based on the preference information, dietary restriction information, and emotional information, and a means for taking the user's ingredient information into account during the filtering process. This allows for the provision of personalized recipes that take into account not only the user's preferences and dietary restrictions, but also their emotional state. Furthermore, by incorporating the user's own ingredient information, the user can use ingredients more efficiently, improving the overall dining experience.

[1635] "Preference information" is data that represents the user's preferences for specific ingredients and cooking styles.

[1636] "Dietary restriction information" is data about ingredients and nutrients that a user wants to avoid for health reasons or personal preferences.

[1637] "Emotion information" is data that indicates the user's current emotional state, and includes states such as "stress," "joy," and "sadness," for example.

[1638] "Ingredient information" is data that indicates a list of ingredients that the user currently owns.

[1639] "Filtering" is the process of selecting information from a database that meets certain conditions based on information received from a user.

[1640] "Randomly selecting" means randomly selecting one of the filtered candidates without using any particular algorithm.

[1641] "Subscription-based" is a service format in which users pay a fixed fee to use the system on a regular basis.

[1642] A "personalized recipe" is a recipe that is specially created based on a user's preference information, dietary restriction information, emotional information, and ingredient information.

[1643] The present invention relates to an online recipe generation system for enhancing a user's dining experience, which receives user preference information, dietary restriction information, ingredient information, and emotional information, and generates and provides personalized recipes based on this information.

[1644] System configuration

[1645] User

[1646] Users input their preferences (e.g., "Italian food," "low carbohydrate," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken," etc.) into the system. Furthermore, the system recognizes their emotional state. This information is transmitted to the system via the user's device.

[1647] Terminal

[1648] The terminal (user's device) provides an interface to acquire user input and emotional state. When the user inputs information and presses the recipe generation button, the terminal sends this information in JSON format to the server.

[1649] server

[1650] The server receives the JSON data sent from the device and performs the following operations:

[1651] 1. Extract user information:

[1652] The server extracts the user ID, preference information, dietary restriction information, ingredient information, and emotion information from the received data.

[1653] 2. Filtering recipes:

[1654] The server filters all recipes in the database based on the user's preferences and dietary restrictions, and also takes into account the user's emotional state to prioritize recipes that are currently suitable for the user.

[1655] 3. Considering ingredient information:

[1656] The server further filters the recipes taking into account the ingredient information the user has.

[1657] 4. Use historical sentiment data:

[1658] The server references past emotion data stored by the emotion engine to assist in selecting recipes to provide a consistent user experience.

[1659] 5. Random recipe selection:

[1660] From the filtered recipes, the server randomly selects one recipe.

[1661] 6. Recipe provided:

[1662] The selected recipe is sent in JSON format to the terminal, which displays it to the user.

[1663] Specific examples

[1664] For example, consider the case where user "user1" enters the following information and the emotion engine recognizes that the user is "feeling stressed":

[1665] Preferences: "Italian food" and "low carbohydrates"

[1666] Dietary Information: "Gluten Free"

[1667] Ingredients: "Tomato" "Chicken"

[1668] When the user presses the recipe generation button, the device sends this information to the server. The server then filters the information and prioritizes recipes that are expected to reduce the user's stress. In this case, an appropriate recipe that is expected to have a relaxing effect, such as "Chicken Alfredo," is selected as a candidate. The server then returns the selected recipe in JSON format to the device, which then displays it to the user.

[1669] Example prompts for generative AI models

[1670] Examples of prompts for generative AI models include:

[1671] "Design a system that generates personalized recipes based on a user's preferences, dietary restrictions, and ingredients. Also consider the user's emotional state."

[1672] Includes:

[1673] The system can improve a user's overall dining experience by providing more personalized recipes based on the user's individual needs.

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

[1675] Step 1:

[1676] Entering user information

[1677] Users input their preferences (e.g., "Italian food," "low carbohydrates," etc.), dietary restrictions (e.g., "gluten-free"), and ingredients (e.g., "tomato," "chicken," etc.) into the terminal. The system also recognizes the user's emotional state.

[1678] Input: User preferences, dietary restrictions, ingredients, and emotional state

[1679] Output: Data summarizing the information entered by the user

[1680] What it does: The user enters information into an application form and uses facial expression analysis cameras and other features to automatically recognize emotional states.

[1681] Step 2:

[1682] Sending information

[1683] When the user presses the recipe generation button, the terminal converts the entered information into JSON format and sends it to the server.

[1684] Input: User-entered preferences, dietary restrictions, ingredients, and emotional state

[1685] Output: User information converted to JSON format

[1686] Specific behavior: Converts data collected from the input form into JSON format and sends it to the server as an HTTP POST request.

[1687] Step 3:

[1688] Receiving and extracting user information

[1689] The server receives the JSON data sent from the device and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional information.

[1690] Input: JSON data sent from the terminal

[1691] Output: Extracted user ID, preference information, dietary restriction information, ingredient information, and emotional information

[1692] Specific behavior: The server's API endpoint parses the JSON data and stores each item in a variable.

[1693] Step 4:

[1694] Initial filtering of recipes

[1695] The server filters the recipes in the database based on the user's preference and dietary restriction information.

[1696] Input: User preferences and dietary restrictions

[1697] Output: Filtered recipe list

[1698] What it does: Extracts recipes that match the preferences and dietary restrictions using a database query (e.g., SQL query).

[1699] Step 5:

[1700] Considering emotional states

[1701] The server prioritizes recipes that are appropriate for the user's emotions from among the recipes filtered based on the emotional state.

[1702] Input: User's emotional information

[1703] Output: A list of recipes further refined based on emotional state

[1704] What it does: Calls the emotion engine, tags recipes related to the emotional state, and adds them to the filtering criteria.

[1705] Step 6:

[1706] Consideration of ingredient information

[1707] The server further filters the recipes taking into account the ingredient information the user has.

[1708] Input: User's ingredient information

[1709] Output: A list of recipes using ingredients you have

[1710] What it does: Re-filter the database for matching recipes based on the ingredients.

[1711] Step 7:

[1712] Use of past emotion data

[1713] The server references previously collected emotion data and integrates it into the current filtering conditions.

[1714] Input: Historical emotion data

[1715] Output: A comprehensive recipe list that also takes into account sentiment data

[1716] What it does: It retrieves past emotion data from the emotion engine via a database query and integrates it into the current recipe selection.

[1717] Step 8:

[1718] Random recipe selection

[1719] The server randomly selects one recipe from the filtered list.

[1720] Input: Filtered recipe list

[1721] Output: A randomly selected recipe

[1722] What it does: Uses a random function to randomly select one recipe from the filtered list of recipes.

[1723] Step 9:

[1724] Recipe provided

[1725] The selected recipe is sent in JSON format to the terminal, which displays it to the user.

[1726] Input: A randomly selected recipe

[1727] Output: The recipe displayed to the user

[1728] Specific operation: Recipe information is converted into JSON format and sent to the terminal as an HTTP response, and the terminal displays the information to the user.

[1729] (Application example 2)

[1730] 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."

[1731] Conventional recipe generation systems suggest recipes based on basic information such as user preferences and dietary restrictions, but do not consider the user's emotional state. As a result, it is difficult to suggest recipes that are in line with the user's mood and emotions on that day. Furthermore, even if a recipe is suggested, there is no mechanism to provide related food delivery options, which means that it is not possible to reduce the effort required for actual meal preparation.

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

[1733] In this invention, the server comprises: means for recognizing the emotional state of the user and filtering recipes based on the emotional state;

[1734] means for receiving preference information and dietary restriction information from a user;

[1735] a means for randomly selecting a recipe from among the filtered recipes;

[1736] Includes:

[1737] This allows recipe suggestions to be tailored not only to a user's preferences but also to their emotional state. Furthermore, by including a means for providing delivery options for related foods, users can easily obtain the foods they need and reduce the effort required for meal preparation. Furthermore, by including a means for performing sentiment analysis using a generative AI model, advanced sentiment recognition becomes possible, resulting in more accurate and personalized recipe suggestions.

[1738] "User" refers to an individual who utilizes the system to receive recipes.

[1739] "Preference information" refers to information about the types of dishes and ingredients that a user particularly likes.

[1740] "Dietary restriction information" refers to information about ingredients and dishes that users should avoid for health or religious reasons.

[1741] "Ingredient information" refers to information about ingredients currently in the user's possession.

[1742] "Emotional state" refers to information about a user's current mood or emotions.

[1743] "Emotion analysis" refers to the technology of analyzing a user's emotional state.

[1744] A "recipe" refers to a list of instructions and ingredients for making a particular dish.

[1745] "Filtering" refers to the process of narrowing down options based on specific criteria.

[1746] "Generative AI model" refers to a mathematical model for generating data using artificial intelligence.

[1747] "Server" refers to a computer system that processes information received from users and generates and serves recipes.

[1748] "Delivery Option" refers to an option that provides a service to deliver related food based on a recipe selected by a user.

[1749] MODE FOR CARRYING OUT THE INVENTION

[1750] The present invention is a system that generates personalized recipes based on a user's preferences, dietary restrictions, available ingredients, and emotional state, and also suggests related delivery options. Specific embodiments of the present invention will be described.

[1751] System configuration

[1752] The system of the present invention comprises the following main components:

[1753] 1. User Device: A device used by a user to access the system, including a smartphone, tablet, or PC. The user device provides an interface for inputting user preference information, dietary restriction information, ingredient information, and emotional state.

[1754] 2. Server: A central computer system that receives and processes information sent from user devices. The server performs recipe filtering, sentiment analysis, and delivery option suggestions.

[1755] 3. Sentiment Analysis Software: Software for analyzing the user's emotional state. It can use IBM Watson's sentiment analysis API or other generative AI models.

[1756] System Operation

[1757] 1. User Input

[1758] Using a device with a dedicated application installed, users input their preferences, dietary restrictions, ingredients, and emotional state, which is then automatically recognized by emotion analysis software.

[1759] 2. Data transmission

[1760] Once the user enters the information, it is sent to the server in JSON format, allowing the server to parse and process the incoming data.

[1761] 3. Processing on the Server

[1762] The server does the following:

[1763] Extract user information: Extract user preference information, dietary restrictions, ingredient information, and emotional state from the received data.

[1764] Recipe filtering: Based on the extracted information, the database is filtered for suitable recipes, and sentiment analysis software is used to consider the user's emotional state and prioritize recipes that best fit their current emotions.

[1765] Random Selection: Randomly select one of the filtered recipes.

[1766] 4. Delivery options available

[1767] It suggests food delivery options related to the selected recipe, making it easy for users to get the ingredients they need.

[1768] 5. Return of Information

[1769] The selected recipe and delivery options are then sent back to the user's device in JSON format, where they are displayed to the user.

[1770] Hardware and software used

[1771] Hardware: User devices are smartphones, tablets, or PCs. Servers are high-performance computer systems.

[1772] Software: The front end is a smartphone application (iOS / Android), the back end is Python's Flask and PostgreSQL, and the sentiment analysis is performed using IBM Watson's sentiment analysis API.

[1773] Specific examples

[1774] For example, if user "user1" enters the following information:

[1775] Preferences: "Italian food" and "low carbohydrates"

[1776] Dietary Information: "Gluten Free"

[1777] Ingredients: "Tomato" "Chicken"

[1778] Emotional state: "Stress"

[1779] Based on this information, the server processes the data and selects an appropriate recipe, such as "Chicken Alfredo," along with delivery options for that related food. The selection is then sent back to the user's device, where the user can review and order delivery.

[1780] Prompt Sentence Examples

[1781] Preferences: "Italian food" and "low carbohydrates"

[1782] Dietary Information: "Gluten Free"

[1783] Ingredients: "Tomato" "Chicken"

[1784] Emotional state: "Stress"

[1785] Use this information to suggest the best recipes and delivery options.

[1786] As described above, the present invention can provide more accurate personalized recipes that take into account not only the user's preferences and dietary restrictions, but also their emotional state, and can also suggest delivery options to help them achieve these recipes.

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

[1788] Step 1:

[1789] User Input

[1790] Users use a dedicated application to input their preferences (e.g., Italian food, low carbohydrates), dietary restrictions (e.g., gluten-free), and ingredients (e.g., tomatoes, chicken). Furthermore, emotion analysis software collects the user's emotional state (e.g., stress) through the application.

[1791] Input: User preference information, dietary restriction information, ingredient information, emotional state

[1792] Output: Data collected by user devices

[1793] Step 2:

[1794] Data transmission

[1795] The device sends the collected user information to the server in JSON format.

[1796] Input: Data collected on the user device

[1797] Output: JSON data sent to the server

[1798] Step 3:

[1799] Extracting User Information

[1800] The server analyzes the received JSON data and extracts the user ID, preference information, dietary restriction information, ingredient information, and emotional state.

[1801] Input: JSON data sent to the server

[1802] Output: Extracted user information

[1803] Step 4:

[1804] Recipe Filtering

[1805] The server filters the recipes in the database based on the extracted user information, specifically using emotion analysis software to prioritize recipes that are appropriate for the user's emotional state.

[1806] Input: Extracted user information

[1807] Data operations: filtering and prioritizing recipes in a database

[1808] Output: Filtered recipe list

[1809] Step 5:

[1810] Applying ingredient information

[1811] The server further performs additional filtering on the filtered recipe list, taking into account ingredient information possessed by the user.

[1812] Input: filtered recipe list, user ingredient information

[1813] Data processing: Selection of recipes that match the ingredient information

[1814] Output: Final filtered recipe list

[1815] Step 6:

[1816] Random Selection

[1817] The server then randomly selects one recipe from the final filtered list of recipes.

[1818] Input: Final filtered recipe list

[1819] Data calculation: Random selection

[1820] Output: Selected recipe

[1821] Step 7:

[1822] Delivery options

[1823] The server generates data suggesting related food delivery options based on the selected recipe.

[1824] Input: Selected recipe

[1825] Data processing: Searching and suggesting relevant food delivery options

[1826] Output: Delivery options list

[1827] Step 8:

[1828] Returning the results

[1829] The server returns the selected recipe and associated delivery options in JSON format to the user device.

[1830] Input: Selected recipe, delivery options list

[1831] Output: JSON data sent back to the user device

[1832] Step 9:

[1833] Displaying Information

[1834] The terminal parses the returned JSON data and displays the selected recipe and delivery options to the user.

[1835] Input: Returned JSON data

[1836] Output: What is displayed to the user

[1837] The above are the specific processing steps of the system for realizing the present invention.

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

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

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

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

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

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

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

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

[1846] 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."

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

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

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

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

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

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

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

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

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

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

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

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

[1859] The following is further disclosed regarding the above embodiment.

[1860] (Claim 1)

[1861] means for receiving preference information and dietary restriction information from a user;

[1862] means for filtering matching recipes based on the preference information and dietary restriction information;

[1863] a means for randomly selecting a recipe from among the filtered recipes;

[1864] The system includes a means for providing a selected recipe to a user.

[1865] (Claim 2)

[1866] 2. The system according to claim 1, further comprising means for receiving ingredient information from a user and filtering recipes taking the ingredient information into consideration.

[1867] (Claim 3)

[1868] 10. The system of claim 1, further comprising means for operating on a subscription basis, allowing a user to periodically receive personalized recipes.

[1869] "Example 1"

[1870] (Claim 1)

[1871] means for receiving preference information and dietary restriction information from a user;

[1872] means for filtering matching recipes based on the preference information and dietary restriction information;

[1873] A means for receiving ingredient information from a user;

[1874] A means for filtering recipes taking into consideration the ingredient information;

[1875] a means for randomly selecting a recipe from among the filtered recipes;

[1876] The system includes a means for providing a selected recipe to a user.

[1877] (Claim 2)

[1878] 10. The system of claim 1, further comprising means for a user to log in and transmit authentication information to the server.

[1879] (Claim 3)

[1880] 10. The system of claim 1, further comprising means for operating on a subscription basis, allowing a user to periodically receive personalized recipes.

[1881] "Application Example 1"

[1882] (Claim 1)

[1883] means for receiving preference information and dietary restriction information from a user;

[1884] means for filtering suitable dishes based on the preference information and dietary restriction information;

[1885] A means of suggesting appropriate dishes from the filtered dishes;

[1886] The system includes means for providing the user with suggested dishes and ordering the appropriate dishes.

[1887] (Claim 2)

[1888] 10. The system according to claim 1, further comprising means for receiving input information from a user and filtering dishes taking said input information into consideration.

[1889] (Claim 3)

[1890] 10. The system of claim 1, further comprising means for operating on a subscription basis, whereby a user can periodically receive personalized cooking suggestions.

[1891] "Example 2: Combining Emotion Engines"

[1892] (Claim 1)

[1893] means for receiving preference information, dietary restriction information, and emotional information from a user;

[1894] means for filtering recipes based on the preference information, dietary restriction information, and emotional information;

[1895] A means for considering user's ingredient information in the filtering process;

[1896] a means for randomly selecting a recipe from among the filtered recipes;

[1897] The system includes a means for providing a selected recipe to a user.

[1898] (Claim 2)

[1899] 10. The system of claim 1, further comprising means for using past emotional data to assist in recipe selection based on emotional information of a user.

[1900] (Claim 3)

[1901] 10. The system of claim 1, further comprising means for operating on a subscription basis, allowing a user to periodically receive personalized recipes.

[1902] "Application example 2 when combining emotion engines"

[1903] (Claim 1)

[1904] means for receiving preference information and dietary restriction information from a user;

[1905] means for filtering matching recipes based on the preference information and dietary restriction information;

[1906] means for recognizing an emotional state of the user and filtering recipes based on the emotional state;

[1907] a means for randomly selecting a recipe from among the filtered recipes;

[1908] The system includes a means for providing a selected recipe to a user.

[1909] (Claim 2)

[1910] 2. The system according to claim 1, further comprising means for receiving ingredient information from a user and filtering recipes taking the ingredient information into consideration.

[1911] (Claim 3)

[1912] 10. The system of claim 1, further comprising means for operating on a subscription basis, allowing a user to periodically receive personalized recipes.

[1913] (Claim 4)

[1914] 10. The system of claim 1, further comprising means for providing related food delivery options based on the recipe.

[1915] (Claim 5)

[1916] 10. The system of claim 1, further comprising means for performing an emotional analysis to recognize an emotional state of the user.

[1917] (Claim 6)

[1918] 6. The system of claim 5, further comprising means for performing the sentiment analysis using a generative AI model. [Explanation of symbols]

[1919] 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. means for receiving preference information and dietary restriction information from a user; means for filtering matching recipes based on the preference information and dietary restriction information; a means for randomly selecting a recipe from among the filtered recipes; The system includes a means for providing a selected recipe to a user.

2. The system according to claim 1 , further comprising means for receiving ingredient information from a user and filtering recipes taking the ingredient information into consideration.

3. 10. The system of claim 1, further comprising means for operating on a subscription basis, allowing a user to periodically receive personalized recipes.

Images