system

Abstract

We provide the system. [Solution] A system comprising: means for receiving ingredient information; means for generating multiple recipes based on the received ingredient information; means for presenting a recipe selected from the recipes generated by the recipe generation means; means for receiving conditions specified by the user; means for filtering recipes generated based on the conditions; means for generating a menu based on the filtered recipes; means for providing recipes corresponding to the menu; means for the user to input daily meal data; means for evaluating the meal data and identifying areas for improvement; and means for proposing a new menu based on the areas for improvement.

Description

Technical Field

[0004] , , , ,

[0005] , , , , ,

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

Background Art

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

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

[0006] "Food ingredient information" refers to data about the type and quantity of food that the user inputs or selects.

[0007] A "recipe" refers to a set of instructions that includes information such as ingredients, cooking steps, and cooking time for preparing a specific dish.

[0008] A "menu" refers to a combination of multiple meals over a specific period (e.g., 1 day, 3 days, 1 week).

[0009] "Conditions" refer to preferences and restrictions set by the user, such as the type of food, allergens, and calorie limits.

[0010] "Filtering" refers to the process of selecting data based on specific criteria and excluding unnecessary data.

[0011] "Meal data" refers to information such as calories and nutrients related to the meals a user consumes on a daily basis.

[0012] "Evaluation" refers to the process of analyzing the current situation based on the input data and making a judgment based on specific criteria.

[0013] An "improvement suggestion" refers to specific advice and action plans to improve the situation by identifying problems and shortcomings based on the current evaluation results.

[0014] A "user terminal" refers to an electronic device (e.g., smartphone, tablet, personal computer) that a user uses to access and operate a system.

[0015] A "server" refers to a computer system that is responsible for data processing and storage for the entire system.

[0016] An "API request" refers to a standardized message used to send data from a device to a server and request a specific function or service.

[0017] A "database" refers to an electronic data management system that systematically stores and efficiently manages information such as ingredient information, recipes, conditions, and meal data. [Brief explanation of the drawing]

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

Mode for Carrying Out the Invention

[0019] Hereinafter, an example of an embodiment of a system according to the technology of the present disclosure will be described with reference to the accompanying drawings.

[0020] First, the language used in the following description will be explained.

[0021] In the following embodiments, a processor with a reference numeral (hereinafter simply referred to as "processor") may be a single arithmetic unit or a combination of a plurality of arithmetic units. Further, the processor may be a single type of arithmetic unit or a combination of a plurality of types of arithmetic units. Examples of arithmetic units include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), an APU (Accelerated Processing Unit), and the like.

[0022] In the following embodiments, signed RAM (Random Access Memory) is a memory that temporarily stores information and is used as work memory by the processor.

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

[0024] In the following embodiments, the signed communication interface (I / F) is an interface that includes a communication processor and an antenna, etc. The communication interface manages communication between multiple computers. Examples of communication standards applicable to the communication interface include wireless communication standards such as 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), or Bluetooth (registered trademark).

[0025] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." That is, "A and / or B" means that it may be A alone, or B alone, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" applies when expressing three or more things linked by "and / or."

[0026] [First Embodiment]

[0027] Figure 1 shows an example of the configuration of the data processing system 10 according to the first embodiment.

[0028] As shown in Figure 1, the 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.

[0029] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0031] The reception device 38 is equipped with a touch panel 38A and a microphone 38B, etc., and receives user input. The touch panel 38A receives user input by detecting contact with an object (e.g., a pen or finger). The microphone 38B receives user input by detecting the user's voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and 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.

[0032] 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 perceptible to the user 20 (e.g., audio and / or text). The display 40A displays visible information such as text and images according to instructions from the processor 46. The speaker 40B outputs audio according to instructions from the processor 46. The camera 42 is a small digital camera equipped with an optical system such as a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0033] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various types of information between processor 46 and processor 28 via network 54.

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

[0035] As shown in Figure 2, in the data processing device 12, a specific processing 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" related to the technology of this 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 according to the specific processing program 56 executed on the RAM 30.

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

[0037] In the smart device 14, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The reception output program 60 is used in conjunction with a 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

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

[0039] The system of this invention generates and provides menus and recipes based on ingredient information and conditions entered by the user. Furthermore, it supports the user's healthy eating habits by evaluating daily meal data and providing suggestions for improving their diet.

[0040] 1. Input and management of ingredient information

[0041] User

[0042] The user enters ingredient information (e.g., carrots, chicken, spinach) through the application's input form.

[0043] terminal

[0044] The entered ingredient information is sent to the server via an API request.

[0045] server

[0046] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[0047] 2. Selection and management of conditions

[0048] User

[0049] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese), allergens, and calorie restrictions in the application's form.

[0050] terminal

[0051] The selected conditions are sent to the server via an API request.

[0052] server

[0053] The received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[0054] 3. Recipe generation and filtering

[0055] server

[0056] Based on the received ingredient information and conditions, the system searches the database for recipes and generates multiple relevant recipes.

[0057] The generated recipes are filtered according to the user's criteria. For example, recipes can be filtered to include only Japanese cuisine, recipes that do not contain allergens, or recipes that meet calorie restrictions.

[0058] 4. Menu planning and serving

[0059] server

[0060] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week).

[0061] The generated menu and corresponding recipe details are sent to the device as an API response.

[0062] terminal

[0063] The received data is visually displayed within the application and provided to the user.

[0064] User

[0065] Review the provided menu and recipe details, and prepare the dishes as needed.

[0066] 5. Input and evaluation of daily meal data

[0067] User

[0068] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[0069] terminal

[0070] The entered meal data is sent to the server via an API request.

[0071] server

[0072] The system analyzes the received meal data to evaluate calorie intake, nutritional balance, and any nutritional deficiencies.

[0073] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on user preferences and health status.

[0074] 6. Providing suggestions for improvement

[0075] server

[0076] Based on the improvement suggestions, a new menu is generated and provided in a way that users can implement the next day or week.

[0077] terminal

[0078] The application displays improvement suggestions received from the server and provides them to the user.

[0079] User

[0080] We will implement the proposed improvements and enhance the quality of our diet.

[0081] Specific example

[0082] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates the optimal recipe based on this information and presents a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system evaluates the data and makes suggestions for necessary improvements. For example, if a user consumes a lot of "blanched spinach," the system might suggest "carrot tempura" the next day to balance the diet.

[0083] This invention allows users to easily maintain a balanced and healthy diet.

[0084] The following describes the processing flow.

[0085] Step 1: Enter ingredient information

[0086] User

[0087] Enter ingredient information into the application's input form. For example, enter specific ingredient names such as "carrots," "chicken," and "spinach."

[0088] terminal

[0089] The entered ingredient information is sent to the server as an API request.

[0090] Step 2: Selecting the conditions

[0091] User

[0092] You select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens (e.g., peanuts, wheat), and calorie restrictions (e.g., 1200 kcal / day) in the application form.

[0093] terminal

[0094] The selected conditions are sent to the server as an API request.

[0095] Step 3: Preservation and pre-processing of ingredient information and conditions

[0096] server

[0097] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalizing ingredient names, removing duplicates). Additionally, the received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[0098] Step 4: Recipe Generation

[0099] server

[0100] Based on the received ingredient information and conditions, the system searches the database for recipes and generates multiple relevant recipes. For example, if the condition is "Japanese food," only Japanese food recipes will be selected.

[0101] Step 5: Filtering Recipes

[0102] server

[0103] The generated recipes are then further filtered based on specific criteria. For example, you can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[0104] Step 6: Menu Generation

[0105] server

[0106] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[0107] Step 7: Provide menus and recipes

[0108] server

[0109] The generated menu and corresponding recipe details are sent to the device as an API response.

[0110] terminal

[0111] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[0112] User

[0113] Review the provided menu and recipe details, and prepare the dishes as needed.

[0114] Step 8: Enter meal data

[0115] User

[0116] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[0117] terminal

[0118] The entered meal data is sent to the server as an API request.

[0119] Step 9: Analysis and evaluation of dietary data

[0120] server

[0121] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[0122] Step 10: Generating improvement suggestions

[0123] server

[0124] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[0125] Step 11: Providing improvement suggestions

[0126] server

[0127] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[0128] terminal

[0129] The application displays improvement suggestions received from the server and provides them to the user.

[0130] User

[0131] Review the proposed improvements and incorporate them into your meals the following day or week.

[0132] By following the steps outlined above, users can maintain a healthy and balanced diet tailored to their individual needs.

[0133] (Example 1)

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

[0135] Traditional meal planning systems required users to manually create menus based on ingredients and other conditions, a cumbersome and time-consuming process. Furthermore, it was difficult to receive suggestions that considered nutritional balance and health conditions. In addition, there were virtually no suggestions for improving dietary habits based on daily meal data. This made it difficult for users to maintain healthy eating habits.

[0136] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0137] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for filtering the generated recipes using a generation AI model, means for receiving user-specified conditions, means for filtering recipes generated based on the conditions, means for automatically generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu and visually displaying them on the user terminal, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, and means for suggesting a new menu based on the areas for improvement. As a result, the user can visually confirm a balanced menu that is automatically generated based on the input ingredient information and specified conditions, and can also receive suggestions for improving their healthy eating habits based on their daily meal data.

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

[0139] A "recipe" is information that includes the steps and a list of ingredients for preparing a specific meal.

[0140] A "generative AI model" is a system or algorithm that uses artificial intelligence technology to generate relevant information from data.

[0141] "Conditions" refer to the constraints and requests that the user specifies when generating a recipe (e.g., type of dish, allergens, calorie restrictions).

[0142] "Filtering" is the process of selecting data based on specific criteria.

[0143] A "menu" is a set of meals planned for a specific period of time.

[0144] "Means of visual display" refers to a mechanism for displaying information graphically on a device.

[0145] "Meal data" refers to data in which users input details about their daily meals and the foods they consumed.

[0146] "Evaluating" is the process of analyzing and making judgments based on the input data.

[0147] "Areas for improvement" are elements that need to be changed or adjusted in order to improve one's diet.

[0148] To "propose" means to show methods or means for achieving a specific objective.

[0149] The system of the present invention generates and provides menus and recipes based on ingredient information and conditions entered by the user. Furthermore, it supports the user's healthy eating habits by evaluating daily meal data and providing suggestions for improving their diet. Specific embodiments are described below.

[0150] 1. Input and management of ingredient information

[0151] The user enters ingredient information (e.g., carrots, chicken, spinach) through the application's input form. At this time, they also enter the ingredient name, quantity, and other detailed information.

[0152] The terminal sends the entered ingredient information to the server via an API request. The terminal converts the input data into an appropriate format (e.g., JSON format) and sends it.

[0153] The server stores the received ingredient information in a database. It performs preprocessing such as normalizing ingredient names and removing duplicates so that "ninjin" and "ninjin" are recognized as the same ingredient.

[0154] 2. Selection and management of conditions

[0155] Users select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens, and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[0156] The device sends the selected conditions to the server via an API request. These conditions are treated as session data.

[0157] The server stores the received conditions as session data and uses them for recipe generation and filtering.

[0158] 3. Recipe generation and filtering

[0159] The server searches the database for recipe data and generates multiple candidate recipes based on the entered ingredient information and conditions. This generation process utilizes a generation AI model to produce highly accurate recipes.

[0160] The server filters recipes generated based on the user's criteria. Specifically, it selects recipes that are Japanese cuisine only, do not contain allergens, and are within calorie limits.

[0161] 4. Menu planning and serving

[0162] The server automatically generates meal plans for a specified period (e.g., 3 days, 1 week) based on filtered recipes. It combines menus suitable for each mealtime (breakfast, lunch, dinner).

[0163] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[0164] The device visually displays the received data within the application and provides it to the user. Details on how the user prepares each recipe are also displayed.

[0165] Users can view the displayed menu and recipe details, then prepare the meal. They can adjust the recipe as needed.

[0166] 5. Input and evaluation of daily meal data

[0167] Users input details about the dishes they actually prepared, the calories they consumed, and their impressions into the application.

[0168] The device sends the entered meal data to the server via an API request.

[0169] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any nutrient deficiencies (e.g., vitamins, minerals). If the user is not getting enough vitamin C, this information is recorded.

[0170] 6. Providing suggestions for improvement

[0171] Based on the analysis results, the server generates improvement suggestions that take into account the user's preferences and health condition. For example, if the user is deficient in vitamin C, it might suggest orange juice for breakfast the next day to compensate for the deficiency.

[0172] The server sends improvement suggestions to the terminal as an API response.

[0173] The device displays the received improvement suggestions within the application and provides them to the user.

[0174] Users implement the suggested improvements and enhance the quality of their diet.

[0175] Specific example

[0176] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates an optimal recipe based on this information. A three-day menu is presented, and the user prepares meals according to it. After that, the system analyzes the meal data entered and balances the diet by suggesting "carrot tempura" for the next day.

[0177] Examples of prompts for generative AI models

[0178] If a user enters "carrots," "chicken," and "spinach," and selects the conditions "Japanese cuisine," "no allergies," and "1200 kcal / day calorie restriction," please generate a 3-day meal plan. Also, please include meal suggestions for the following day to ensure balance.

[0179] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0180] Step 1:

[0181] The user enters ingredient information (e.g., carrots, chicken, spinach) into the application's input form.

[0182] Input: Ingredient information entered by the user.

[0183] Output: Ingredient information is temporarily stored within the application.

[0184] Specific operation: When the user enters text into the form and presses the confirmation button, the information proceeds to the next step.

[0185] Step 2:

[0186] The terminal sends the entered ingredient information to the server via an API request.

[0187] Input: Ingredient information entered in Step 1.

[0188] Output: Ingredient information is sent to the server.

[0189] Specific operation: The terminal converts the entered ingredient information into JSON format and sends an HTTP POST request to the API endpoint.

[0190] Step 3:

[0191] The server stores the received ingredient information in a database.

[0192] Input: Ingredient information sent from the device.

[0193] Output: Ingredient information is saved in the database.

[0194] Specific operation: The server saves the received data to the appropriate table in the database using an INSERT statement, and performs normalization and duplicate removal of ingredient names as needed.

[0195] Step 4:

[0196] Users select conditions such as the type of cuisine (Japanese, Western, or Chinese), allergens, and calorie restrictions in an input form.

[0197] Input: User-selected criteria information.

[0198] Output: Condition information is temporarily stored within the application.

[0199] Specific operation: When the user selects conditions using a dropdown menu or checkboxes and presses the confirmation button, the information proceeds to the next step.

[0200] Step 5:

[0201] The device sends the selected conditions to the server via an API request.

[0202] Input: Condition information entered in Step 4.

[0203] Output: Condition information is sent to the server.

[0204] Specific operation: The terminal converts the selected conditions into JSON format and sends an HTTP POST request to the API endpoint.

[0205] Step 6:

[0206] The server stores the received conditions as session data and uses them for subsequent recipe generation and filtering.

[0207] Input: Conditional information sent from the terminal.

[0208] Output: Condition information is saved to the server as session data.

[0209] Specific operation: The server stores the received data in memory as session data and also backs it up in the database.

[0210] Step 7:

[0211] The server searches the database for recipe data and generates multiple candidate recipes based on the entered ingredient information and conditions. This generation process utilizes a generation AI model.

[0212] Input: Recipe data, ingredient information, and condition information from the database.

[0213] Output: Multiple candidate recipes are generated.

[0214] Specific operation: Using a generative AI model, ingredient information and condition information are provided as input, and highly relevant recipes are generated. The generated recipes are temporarily stored in memory.

[0215] Step 8:

[0216] The server filters the recipes generated based on the user's criteria.

[0217] Input: Multiple generated candidate recipes, user criteria information.

[0218] Output: Filtered list of recipes.

[0219] Specific operation: The server uses conditional information to filter candidate recipes, selecting those that are Japanese cuisine only, do not contain allergens, or are within calorie limits.

[0220] Step 9:

[0221] The server automatically generates meal plans for a specified period (e.g., 3 days, 1 week) based on the filtered recipes.

[0222] Input: Filtered list of recipes.

[0223] Output: Automatically generated menu for the specified period.

[0224] Specific operation: The server generates balanced menus by combining menus suitable for each mealtime (breakfast, lunch, and dinner), making it easy for the user to prepare them.

[0225] Step 10:

[0226] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[0227] Input: Automatically generated menu and its details.

[0228] Output: Menu and recipe details sent to the device as an API response.

[0229] Specific operation: The server converts the generated menu and recipe details into JSON format and sends it as an HTTP response to the appropriate API endpoint.

[0230] Step 11:

[0231] The device visually displays the received data within the application.

[0232] Input: Menu and recipe details sent from the server.

[0233] Output: Menu and recipe details displayed visually within the application.

[0234] Specific operation: The terminal parses the received JSON data and visually formats it using HTML and CSS to display it in the user interface.

[0235] Step 12:

[0236] Users review the provided menu and recipe details and then prepare the dishes.

[0237] Input: Displayed menu and recipe details.

[0238] Output: Confirmed menu and prepared dishes.

[0239] Specific actions: The user checks the recipe details displayed on the screen and then actually prepares the dish.

[0240] Step 13:

[0241] Users input details about the dishes they actually prepared, the calories they consumed, and their impressions into the application.

[0242] Input: Details of the meals actually consumed.

[0243] Output: Input meal data.

[0244] Specific operation: The user enters detailed information into the input form and presses the submit button to advance the data to the next step.

[0245] Step 14:

[0246] The device sends the entered meal data to the server via an API request.

[0247] Input: Meal data entered by the user.

[0248] Output: Meal data sent to the server.

[0249] Specific operation: The device converts the meal data into JSON format and sends it to the appropriate API endpoint via an HTTP POST request.

[0250] Step 15:

[0251] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any missing nutrients.

[0252] Input: Meal data entered by the user.

[0253] Output: Evaluation results (calorie intake, nutritional balance, deficient nutrients, etc.).

[0254] Specific operation: The server analyzes the received meal data, calculates the daily nutrient intake, evaluates the nutritional balance, and identifies any deficient nutrients.

[0255] Step 16:

[0256] The server generates improvement suggestions based on the evaluation results, taking into account the user's preferences and health condition.

[0257] Input: Evaluated meal data, user preferences, and health status.

[0258] Output: Improvement suggestions.

[0259] Specific operation: The server suggests the content and menu of meals for the next day, based on evaluation results and the user's past eating history. For example, if the user is deficient in vitamin C, it will suggest orange juice for breakfast.

[0260] Step 17:

[0261] The server sends improvement suggestions to the terminal as an API response.

[0262] Input: Generated improvement suggestions.

[0263] Output: Improvement suggestions sent to the terminal as an API response.

[0264] Specific operation: The server converts the improvement suggestions into JSON format and sends them as an HTTP response to the appropriate API endpoint.

[0265] Step 18:

[0266] The device displays the received improvement suggestions within the application.

[0267] Input: Improvement suggestions sent from the server.

[0268] Output: Improvement suggestions visually displayed within the application.

[0269] Specific operation: The terminal parses the received JSON data and visually formats it using HTML and CSS to display it in the user interface.

[0270] Step 19:

[0271] Users implement the suggested improvements and enhance the quality of their diet.

[0272] Input: Displayed improvement suggestions.

[0273] Output: Improved eating habits as a result of implementing the proposed improvements.

[0274] Specific actions: Users maintain a healthy diet by preparing ingredients according to the displayed improvement suggestions and incorporating them into their next meal.

[0275] (Application Example 1)

[0276] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0277] In modern society, maintaining a healthy diet amidst a busy lifestyle is a challenging task. Furthermore, creating nutritionally balanced meal plans is time-consuming, highlighting the need for a user-friendly system. Additionally, there is a lack of economic incentives to encourage the purchase of healthy ingredients. Therefore, a system is needed that provides optimal recipes and meal plans based on ingredient information, and also offers cashback to further promote the purchase of healthy ingredients.

[0278] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0279] In this invention, the server includes means for receiving food ingredient information, means for generating a plurality of recipes based on the received food ingredient information, means for presenting the recipe selected from the recipes generated by the recipe generation means, means for receiving the conditions specified by the user, means for filtering the recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing the recipes corresponding to the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying improvement points, means for proposing a new menu based on the improvement points, and means for providing a cashback when purchasing healthy food ingredients based on the new menu. As a result, the user can easily maintain a balanced diet and also obtain an incentive to purchase healthy food ingredients, so that it is possible to simultaneously enjoy maintaining and improving health and economic convenience.

[0280] The "means for receiving food ingredient information" is a method or device for the system to receive data on the types and amounts of food ingredients input by the user.

[0281] The "means for generating a plurality of recipes based on the received food ingredient information" is an algorithm or program for proposing a plurality of recipes for corresponding dishes based on the input food ingredient information.

[0282] The "means for presenting the recipe selected from the recipes generated by the recipe generation means" is a method or interface for displaying a specific recipe to the user from among the generated plurality of recipes.

[0283] The "means for receiving the conditions specified by the user" is a method or function for receiving, as an input from the user, conditions such as the type of dish, allergy information, calorie limit, etc.

[0284] The "means for filtering the recipes generated based on the conditions" is an algorithm or program for narrowing down the generated recipes in consideration of the conditions specified by the user.

[0285] The "means for generating a menu based on the filtered recipe" is a method or program for creating a meal plan (menu) for a certain period using the filtered recipe.

[0286] The "means for providing a recipe corresponding to the menu" is a method or function for providing the user with the recipe of a specific dish based on the created menu.

[0287] The "means for the user to input daily meal data" is an interface or device for the user to input the content of the meals actually consumed into the system.

[0288] The "means for evaluating meal data and identifying improvement points" is an algorithm or program for analyzing the input meal data and finding improvement points from the perspectives of nutritional balance and calorie intake.

[0289] The "means for proposing a new menu based on the improvement points" is a method or program for proposing a new meal plan (menu) to the user considering the identified improvement points.

[0290] The "means for providing a cashback when purchasing healthy ingredients based on the new menu" is a system or service for providing an economic incentive (cashback) to the user by purchasing the ingredients included in the proposed menu.

[0291] To implement this invention, the following system configuration and program are utilized.

[0292] System Configuration

[0293] Hardware and Software

[0294] Server: Flask (Python), MySQL (registered trademark) or PostgreSQL, scikit-learn, TENSORFLOW (registered trademark)

[0295] User device: Smartphone application (ANDROID® / iOS)

[0296] System Operation Description

[0297] Input and management of ingredient information

[0298] The user enters ingredient information (e.g., carrots, chicken, spinach) through an input form in a smartphone application. The application sends this information to the server as an API request, and the server stores the received ingredient information in a database. The stored data is preprocessed (e.g., normalization of ingredient names, removal of duplicates).

[0299] Selection and management of conditions

[0300] Users can select the type of dish, allergy information, calorie restrictions, etc., through the application's form. These conditions are sent to the server via API requests and temporarily stored as session data. This data is then used for subsequent recipe generation and filtering.

[0301] Recipe generation and filtering

[0302] The server generates multiple relevant recipes using a generative AI model based on the received ingredient information and conditions. It then filters the recipes based on these conditions, for example, selecting only Japanese cuisine, recipes that do not contain allergens, or recipes within calorie limits.

[0303] Menu planning and serving

[0304] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). The generated meal plans and corresponding recipe details are sent to the device as an API response, allowing the user to visually confirm them within the application.

[0305] Input and Evaluation of Daily Diet Data

[0306] The user inputs into the application the dishes they actually made, the content of the meals they consumed, calories, impressions, etc. The application sends this data to the server, and the server analyzes the received data to evaluate the calorie intake and nutritional balance, and identifies nutrients that are lacking.

[0307] Provision of Improvement Suggestions

[0308] Based on the evaluation results, improvement suggestions are generated considering the user's preferences and health status, and new meal plans are proposed. Furthermore, a mechanism is provided where cashback can be obtained when purchasing specific healthy ingredients.

[0309] Specific Example

[0310] For example, when the user inputs ingredients such as "carrot", "chicken", and "spinach", and selects conditions such as "Japanese cuisine", "no allergies", and "calorie limit of 1200 kcal / day", the server generates an optimal recipe based on this information and presents a three-day meal plan. When the user creates meals according to this meal plan and inputs the meal data, the system evaluates the data and makes necessary improvement suggestions. For example, on a day when a large amount of "spinach salad" is consumed, balance is achieved by suggesting "carrot tempura" the next day. Also, by introducing a mechanism where cashback can be obtained when purchasing this ingredient, it supports the user in maintaining a healthy diet.

[0311] Examples of Prompt Sentences

[0312] Please propose a Japanese cuisine recipe using "carrot", "chicken", and "spinach". The calorie limit is within 1200 kcal / day. There is no allergy information.

[0313] The flow of specific processing in Application Example 1 will be described using FIG. 12.

[0314] Step 1:

[0315] The user enters ingredient information (e.g., carrots, chicken, spinach) through an input form in the smartphone application. Once the user has finished entering the information, the application formats this ingredient information in JSON format and sends it to the server via an API request. The server saves the received ingredient information to a database and performs pre-processing such as normalizing ingredient names and removing duplicates before saving. In this step, the input is the ingredient information entered by the user, and the output is the saving of the pre-processed ingredient information to the database.

[0316] Step 2:

[0317] The user selects individual conditions such as the type of dish, allergy information, and calorie restrictions through a form in the smartphone application. Once the user has made their selections, the application formats these conditions in JSON format and sends them to the server via an API request. The server temporarily stores the received condition data as session data and uses it for subsequent recipe generation and filtering processes. The input for this step is the condition data selected by the user, and the output is the storage of the session data.

[0318] Step 3:

[0319] The server generates multiple recipes using a generative AI model based on ingredient information and condition data stored in the database. The AI ​​model utilizes the input ingredient information to extract and generate relevant recipes from the corresponding recipe database. The generated recipes are temporarily stored in a cache. The input for this step is ingredient information and condition data, and the output is the generated recipe data.

[0320] Step 4:

[0321] The server filters the generated recipe data based on conditional data. For example, it extracts only recipes that meet the user's criteria, such as Japanese food only, recipes that do not contain allergens, or recipes that are within calorie limits. The filtered recipe data is then stored in the cache again. The input for this step is the generated recipe data and conditional data, and the output is the filtered recipe data.

[0322] Step 5:

[0323] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on the filtered recipes. The generated meal plans and corresponding recipe details are sent to the user's device as an API response. The user can visually view these meal plans and recipe details within the application. The input for this step is filtered recipe data and a specified period, and the output is the generated meal plan data.

[0324] Step 6:

[0325] Users input details such as the dishes they actually prepared, the meals they ate, calories, and their impressions into a smartphone application. The application formats this meal data in JSON format and sends it to the server via an API request. The server analyzes the received meal data, evaluates calorie intake and nutritional balance, and identifies any deficient nutrients. The input for this step is the meal data entered by the user, and the output is the evaluation result data.

[0326] Step 7:

[0327] The server generates improvement suggestions based on the evaluation results, taking into account the user's preferences and health status. It automatically generates a new menu based on the suggested improvements and provides it in a way that the user can implement the next day or week. Furthermore, the application displays a mechanism offering a cashback incentive for purchasing healthy ingredients based on this new menu. The input for this step is the evaluation result data, and the output is the improvement suggestions and cashback information.

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

[0329] This invention is a system that recognizes the user's emotions in addition to the ingredient information and conditions entered by the user, and generates and provides recipes and menus based on those emotions. This system not only improves the quality of the user's diet but also supports a healthier and more satisfying diet by taking into account the user's emotional state.

[0330] 1. Input and management of ingredient information

[0331] User

[0332] The user enters ingredient information into the application's input form. For example, they might enter specific ingredients such as "carrots," "chicken," or "spinach."

[0333] terminal

[0334] The entered ingredient information is sent to the server via an API request.

[0335] server

[0336] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[0337] 2. Selection and management of conditions

[0338] User

[0339] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens (e.g., peanuts, wheat, etc.), and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[0340] terminal

[0341] The selected conditions are sent to the server via an API request.

[0342] server

[0343] The received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[0344] 3. Utilizing the Emotion Engine

[0345] User

[0346] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select options such as "feeling stressed," "feeling happy," or "feeling tired."

[0347] terminal

[0348] The emotional data is sent to the server as an API request.

[0349] server

[0350] Based on the received emotional data, the system analyzes the user's emotional state and generates recipes and menus that are appropriate for that state.

[0351] 4. Recipe generation and filtering

[0352] server

[0353] Based on the received ingredient information, conditions, and emotional data, the system searches the database for recipes and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[0354] server

[0355] The generated recipes are then further filtered based on specific criteria. For example, you can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[0356] 5. Menu creation and provision

[0357] server

[0358] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[0359] server

[0360] The generated menu and corresponding recipe details are sent to the device as an API response.

[0361] terminal

[0362] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[0363] User

[0364] Review the provided menu and recipe details, and prepare the dishes as needed.

[0365] 6. Input and evaluation of daily meal data

[0366] User

[0367] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[0368] terminal

[0369] The entered meal data is sent to the server as an API request.

[0370] server

[0371] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[0372] 7. Generating and providing improvement suggestions

[0373] server

[0374] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[0375] server

[0376] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[0377] terminal

[0378] The application displays improvement suggestions received from the server and provides them to the user.

[0379] User

[0380] Review the proposed improvements and incorporate them into your meals the following day or week.

[0381] Specific example

[0382] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and also inputs their emotional state as "feeling stressed," the server will generate an optimal recipe based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system will evaluate the data and make suggestions for necessary improvements. For example, if the user consumes a lot of "blanched spinach, which has a relaxing effect," the system will balance this by suggesting "glazed carrots, which help reduce stress," on the next day.

[0383] This invention allows users to easily achieve a healthy and balanced diet tailored to their individual circumstances and emotional state.

[0384] The following describes the processing flow.

[0385] Step 1: Enter ingredient information

[0386] User

[0387] Enter ingredient information into the application's input form. For example, enter specific ingredients such as "carrots," "chicken," and "spinach."

[0388] terminal

[0389] The entered ingredient information is sent to the server as an API request.

[0390] Step 2: Selecting the conditions

[0391] User

[0392] You select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens (e.g., peanuts, wheat), and calorie restrictions (e.g., 1200 kcal / day) in the application form.

[0393] terminal

[0394] The selected conditions are sent to the server as an API request.

[0395] Step 3: Preservation and pre-processing of ingredient information and conditions

[0396] server

[0397] The received ingredient information and conditions are saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[0398] Step 4: Entering emotional data

[0399] User

[0400] The application allows users to input or recognize their current emotional state through an emotion input form or emotion recognition function. For example, they can choose from options such as "feeling stressed," "feeling happy," or "feeling tired."

[0401] terminal

[0402] The emotional data is sent to the server as an API request.

[0403] Step 5: Saving and analyzing emotional data

[0404] server

[0405] The received emotional data is stored in a database and analyzed. This allows for the identification of appropriate recipes and menus based on the user's emotional state.

[0406] Step 6: Recipe Generation

[0407] server

[0408] Based on the received ingredient information, conditions, and emotional data, the system searches the database for recipes and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[0409] Step 7: Filtering Recipes

[0410] server

[0411] The generated recipes are then filtered based on specific criteria. For example, recipes can be narrowed down by conditions such as "does not contain allergens" or "is within calorie limits."

[0412] Step 8: Menu Generation

[0413] server

[0414] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[0415] Step 9: Provide menus and recipes

[0416] server

[0417] The generated menu and corresponding recipe details are sent to the device as an API response.

[0418] terminal

[0419] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[0420] User

[0421] Review the provided menu and recipe details, and prepare the dishes as needed.

[0422] Step 10: Enter meal data

[0423] User

[0424] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[0425] terminal

[0426] The entered meal data is sent to the server as an API request.

[0427] Step 11: Analysis and evaluation of dietary data

[0428] server

[0429] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[0430] Step 12: Generating improvement suggestions

[0431] server

[0432] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[0433] Step 13: Providing improvement suggestions

[0434] server

[0435] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[0436] terminal

[0437] The application displays improvement suggestions received from the server and provides them to the user.

[0438] User

[0439] Review the proposed improvements and incorporate them into your meals the following day or week.

[0440] By following the steps outlined above in sequence, users can maintain a healthy and balanced diet tailored to their individual circumstances and emotional state.

[0441] (Example 2)

[0442] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0443] In modern life, balancing health and diet is becoming increasingly important. However, it is extremely difficult for users to manage daily ingredient selection, recipe planning, and meal planning tailored to their emotional state all at once. In particular, excluding allergens, restricting calories, and simultaneously suggesting menus based on the user's emotions and health condition are challenging with current systems. Furthermore, features that evaluate daily meal data and suggest improvements are generally lacking. An efficient system is needed to solve these problems.

[0444] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0445] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, means for proposing a new menu based on the areas for improvement, means for inputting or recognizing the user's emotional state, and means for analyzing the emotional state and generating recipes and menus based thereon. As a result, the user can centrally manage ingredient selection, recipe selection, and menu creation tailored to their emotional state in their daily diet, and also receive improvement suggestions according to their health condition.

[0446] "Ingredient information" refers to the specific names of ingredients entered by the user, and indicates the ingredients used in the dish.

[0447] A "recipe generation method" refers to a device or program that has the function of generating a series of cooking procedures and ingredient combinations based on the received ingredient information.

[0448] A "recipe presentation means" refers to a device or program that selects and displays a recipe to be presented to the user from among the recipes generated by the recipe generation means.

[0449] "Conditions" refer to individual requirements specified by the user, such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens, and calorie restrictions.

[0450] A "filtering device" refers to a device or program that selects recipes that match specified conditions from among the generated recipes.

[0451] A "menu generation method" refers to a device or program that automatically assembles a menu for a period specified by the user, based on filtered recipes.

[0452] A "recipe provisioning means" refers to a device or program that provides users with detailed information on the generated menu and its corresponding recipe.

[0453] "Meal data" refers to information about the user's daily meals, including the type of food consumed, calories, and comments.

[0454] "Evaluation means" refers to devices or programs that analyze received meal data and evaluate information such as calorie intake and nutritional balance.

[0455] "Improvement suggestion means" refers to devices or programs that propose new menus based on the areas for improvement identified by the evaluation means.

[0456] "Emotional state" refers to the user's current mental state as input or perceived (for example, feeling stressed, happy, tired, etc.).

[0457] "Emotional analysis means" refers to devices or programs that analyze the emotional state received and generate recipes or menus based on the user's emotions and mood.

[0458] This invention is a system that recognizes the user's emotional state in addition to the ingredient information and conditions entered by the user, and generates and provides recipes and menus based on that. This system not only improves the quality of the user's diet but also supports a healthier and more satisfying diet by taking into account the user's emotional state.

[0459] The implementation of this invention is realized through devices and software that have three main roles: server, terminal, and user.

[0460] server

[0461] The server includes a database (e.g., MySQL, PostgreSQL) for receiving, storing, and pre-processing ingredient information, as well as programs for recipe generation, filtering, sentiment analysis, and menu generation. It is also responsible for evaluating received meal data and generating improvement suggestions. The server also includes an interface for communicating with terminals via API requests.

[0462] terminal

[0463] The terminal provides an input form for the user and sends information such as ingredient information, conditions, emotional state, and meal data to the server as an API request. It also visualizes and provides the user with recipes, menus, and improvement suggestions received from the server. The terminal can be implemented on a variety of devices, including smartphones, tablets, and personal computers.

[0464] User

[0465] Users input ingredient information, conditions, emotional state, and meal data through their device. Furthermore, they utilize the system by creating dishes based on provided recipes and menus, and then inputting data on the meals they actually consumed.

[0466] As a concrete example, if a user uses "carrots," "chicken," and "spinach," sets the conditions of "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and enters "feeling stressed" as their emotional state, the server will generate recipes based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and enters the meal data, the system will analyze the data and, the following day, offer suggestions for improvement, such as "glazed carrots to help reduce stress."

[0467] Examples of prompt statements are as follows:

[0468] "If a user wants to make Japanese food using carrots, chicken, and spinach, what should they do?"

[0469] "Please generate a meal plan suitable for a user who has no allergies, desires a calorie restriction of 1200 kcal / day, and is also experiencing stress."

[0470] This invention allows users to efficiently select ingredients, decide on recipes, and create menus tailored to their emotional state, while also receiving suggestions for improvements based on their health condition. This system contributes to improving the quality of diet and increasing user satisfaction.

[0471] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0472] Step 1:

[0473] The user enters ingredient information. The user enters specific ingredients such as "carrots," "chicken," and "spinach" into the application's input form. The entered ingredient information is sent to the device.

[0474] Step 2:

[0475] The terminal sends ingredient information to the server. The entered ingredient information is sent to the server in the form of an API request. The communication protocol used is HTTP / HTTPS. The input data is often encoded in JSON format.

[0476] Step 3:

[0477] The server stores and preprocesses the ingredient information. The received ingredient information is stored in a database (e.g., MySQL, PostgreSQL). Then, data preprocessing is performed, such as normalizing ingredient names (e.g., unifying "ninjin" to "ninjin") and removing duplicates. The output is formatted ingredient information.

[0478] Step 4:

[0479] The user selects the conditions. The user enters conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens, and calorie restrictions (e.g., 1200 kcal / day) into the application's form. The entered data is saved on the device.

[0480] Step 5:

[0481] The device sends the conditions to the server. The selected conditions are sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the condition data is encoded in JSON format.

[0482] Step 6:

[0483] The server saves the conditions. The received condition data is saved as session data and used for subsequent recipe generation and filtering. The condition data is saved as session data as output.

[0484] Step 7:

[0485] The user inputs emotional data. They use an emotional input form or emotional recognition function to enter their current emotional state (e.g., "feeling stressed"). The emotional data is saved on the device.

[0486] Step 8:

[0487] The device sends emotional data to the server. The emotional data is sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the emotional data is encoded in JSON format.

[0488] Step 9:

[0489] The server analyzes the emotional data. It analyzes the received emotional data to understand the user's emotional state. The analysis is performed using NLP (Natural Language Processing) libraries (e.g., NLTK, spaCy) and emotion analysis models. As a result of the analysis, tags and scores corresponding to the emotional state are obtained.

[0490] Step 10:

[0491] The server generates and filters recipes. It searches the recipe database based on received ingredient information, conditions, and sentiment data, generating multiple relevant recipes. Furthermore, it filters the recipes based on conditions such as "does not contain allergens" and "is within calorie limits." The output is a filtered list of recipes.

[0492] Step 11:

[0493] The server generates a menu and sends it to the terminal. Based on the filtered recipes, it automatically generates a menu for the period specified by the user. The generated menu and recipe details are sent to the terminal as an API response. Menu data is obtained as output.

[0494] Step 12:

[0495] The device displays the menu. The received menu and recipe details are visually displayed within the application. This can be done in a calendar format, and detailed information for each recipe can be viewed with a click. The user reviews this information and prepares the meal.

[0496] Step 13:

[0497] The user inputs meal data. They enter details such as the dishes they actually prepared, the meals they ate, calories, and their impressions into the application. The meal data is saved on the device.

[0498] Step 14:

[0499] The device sends meal data to the server. The entered meal data is sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the meal data is encoded in JSON format.

[0500] Step 15:

[0501] The server analyzes and evaluates the meal data. It analyzes the received meal data and evaluates factors such as calorie intake and nutritional balance. It checks whether specific nutrients are deficient or excessive. The evaluation results are provided as output.

[0502] Step 16:

[0503] The server generates improvement suggestions and sends them to the terminal. Based on the evaluation results, it identifies areas for improvement and generates new improvement suggestions based on the user's preferences and health status. The generated improvement suggestions are sent to the terminal as an API response. The output is improvement suggestion data.

[0504] Step 17:

[0505] The device displays improvement suggestions. Received improvement suggestions are displayed within the application. The user reviews them and incorporates them into their meals for the following day or week.

[0506] (Application Example 2)

[0507] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as a "server" and the smart device 14 as a "terminal".

[0508] Traditional recipe suggestion systems propose recipes based on ingredients and conditions specified by the user. However, this fails to consider the user's emotional state, resulting in meal suggestions that may not be suitable for the user's current mood or health condition. Furthermore, they often lack the functionality to automatically generate menus for multiple days and order ingredients in bulk based on those menus. In addition, they are insufficient in utilizing data on meals actually prepared by the user to provide continuous healthy meal suggestions.

[0509] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for recognizing the user's emotional state, means for optimizing the recipes based on the emotional state, means for automatically generating a menu based on the filtered recipes and presenting menus for each period, means for ordering meals based on the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, and means for proposing a new menu based on the areas for improvement. This makes it possible to propose recipes and menus that take into account the user's emotional state, thereby supporting a healthy and satisfying diet. Furthermore, by providing a function to order ingredients in bulk based on the automatically generated menu, the user's workload can be reduced.

[0510] "Means for receiving ingredient information" refers to an interface that allows the system to receive ingredient information entered by the user and send it to the server.

[0511] "Means for generating multiple recipes" refers to algorithms and processes for searching a database for and generating multiple recipes based on the received ingredient information.

[0512] "A means of presenting a recipe selected from a list of recipes" refers to an interface for presenting the user with the most suitable recipe from among those that have been generated.

[0513] "Means for receiving user-specified conditions" refers to an interface that allows the system to receive conditions entered by the user, such as the type of food, allergy information, and calorie restrictions, and send them to the server.

[0514] "Means for filtering recipes generated based on conditions" refers to algorithms and processes for selecting appropriate recipes based on conditions specified by the user.

[0515] "Means for generating menus" refers to algorithms and processes for automatically generating menus for a specified period by combining selected recipes.

[0516] "Means of providing recipes corresponding to menus" refers to an interface for providing users with generated menus and their corresponding recipes.

[0517] "Means for recognizing the user's emotional state" refers to an input interface and emotion analysis algorithm that the system uses to recognize the user's current emotional state (e.g., stress, happiness, fatigue).

[0518] "Means for optimizing the recipe based on emotional state" refers to an algorithm and process for selecting and suggesting the most suitable recipe to the user, taking into account the recognized emotional state.

[0519] "A means of automatically generating menus and presenting them for each period" refers to an interface that automatically generates menus for a period specified by the user (e.g., 3 days, 1 week) and presents them to the user in a calendar format.

[0520] "A means of ordering meals based on a menu" refers to an interface for ordering specific meals as a food delivery service based on a generated menu.

[0521] "A means of inputting daily meal data" refers to an interface for users to input data into the system, such as the content of meals they actually ate, calories, and their impressions.

[0522] "Methods for evaluating dietary data and identifying areas for improvement" refers to algorithms and processes for analyzing input dietary data, evaluating nutritional balance and calorie intake, and identifying areas for improvement.

[0523] "Methods for suggesting new menus based on areas for improvement" refers to algorithms and processes for suggesting new menus to users based on identified areas for improvement.

[0524] In order to implement this invention, the main components—the server, terminal, and user—must function in coordination. The following describes a specific system embodiment and its processing.

[0525] 1. Input and management of ingredient information

[0526] User:

[0527] The user enters ingredient information into the application's input form. For example, they might enter specific ingredient information such as "carrots," "chicken," and "spinach."

[0528] Terminal:

[0529] The terminal sends the entered ingredient information to the server via an API request.

[0530] server:

[0531] The server stores the received ingredient information in a database and performs preprocessing as needed, such as normalizing ingredient names and removing duplicates.

[0532] 2. Selection and management of conditions

[0533] User:

[0534] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens (e.g., peanuts, wheat, etc.), and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[0535] Terminal:

[0536] The device sends the selected conditions to the server via an API request.

[0537] server:

[0538] The server temporarily stores the received conditions as session data and uses them for subsequent recipe generation and filtering.

[0539] 3. Utilizing the Emotion Engine

[0540] User:

[0541] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select options such as "feeling stressed," "feeling happy," or "feeling tired."

[0542] Terminal:

[0543] The device sends emotional data to the server as an API request.

[0544] server:

[0545] The server analyzes the user's emotional state based on the received emotional data and generates recipes and menus that are appropriate for that state.

[0546] 4. Recipe generation and filtering

[0547] server:

[0548] The server searches its database for recipes based on the received ingredient information, conditions, and emotional data, and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[0549] server:

[0550] The server further filters the generated recipes based on specific criteria. For example, it can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[0551] 5. Menu creation and provision

[0552] server:

[0553] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on filtered recipes. For example, it might combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[0554] server:

[0555] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[0556] Terminal:

[0557] The device visually displays the received data within the application and provides it to the user. Specifically, it can display menus in a calendar format and allow users to view detailed information about each recipe with a click.

[0558] User:

[0559] Users review the provided menu and recipe details and prepare the dishes as needed.

[0560] 6. Input and evaluation of daily meal data

[0561] User:

[0562] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[0563] Terminal:

[0564] The terminal sends the entered meal data to the server as an API request.

[0565] server:

[0566] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[0567] 7. Generating and providing improvement suggestions

[0568] server:

[0569] The server identifies areas for improvement based on the evaluation results and generates new improvement suggestions based on the user's preferences and health status. For example, it might suggest a menu with more salad the next day to compensate for a lack of vegetables.

[0570] server:

[0571] Based on the improvement suggestions, the server generates a new menu and provides it to the user so they can try it the next day or the following week.

[0572] Terminal:

[0573] The terminal displays improvement suggestions received from the server within the application and provides them to the user.

[0574] User:

[0575] Users review the suggested improvements and incorporate them into their meals the following day or week.

[0576] Specific example

[0577] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and also inputs their emotional state as "feeling stressed," the server will generate an optimal recipe based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system will evaluate the data and provide suggestions for necessary improvements. For example, on a day when the user has consumed a lot of "blanched spinach, which has a relaxing effect," the system may suggest "glazed carrots, which help reduce stress," on the next day to balance things out.

[0578] Example of a prompt:

[0579] "Today's ingredients are carrots and chicken, but I'm feeling stressed. Please suggest a relaxing Japanese recipe under 1200 kcal."

[0580] Thus, the system of this invention is designed to take into account the user's emotional state and support a healthy and satisfying diet. Furthermore, by providing a function to order ingredients in bulk based on automatically generated menus, it reduces the effort required of the user.

[0581] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0582] Step 1:

[0583] User:

[0584] The user enters food information into the application's input form. For example, they enter specific ingredients such as "carrots," "chicken," and "spinach." The entered food information is then sent to the device.

[0585] Input: carrots, chicken, spinach

[0586] Output: Ingredient information sent to the terminal

[0587] Step 2:

[0588] Terminal:

[0589] The terminal sends the entered ingredient information to the server via an API request.

[0590] Input: Ingredient information entered by the user

[0591] Output: Ingredient information sent to the server

[0592] Step 3:

[0593] server:

[0594] The server stores the received ingredient information in a database. Before saving, it performs preprocessing such as normalizing ingredient names and removing duplicates.

[0595] Input: Food ingredient information received from the terminal

[0596] Output: Normalized and deduplication-removed database entries

[0597] Step 4:

[0598] User:

[0599] Users select conditions such as the type of cuisine, allergens, and calorie restrictions through the application's form.

[0600] Input: Japanese food, no allergies, 1200 kcal / day

[0601] Output: Condition information sent to the terminal

[0602] Step 5:

[0603] Terminal:

[0604] The device sends the selected condition information to the server via an API request.

[0605] Input: User-selected condition information

[0606] Output: Condition information sent to the server

[0607] Step 6:

[0608] server:

[0609] The server temporarily stores the received condition information as session data and uses it for subsequent recipe generation and filtering.

[0610] Input: Conditional information received from the device

[0611] Output: Condition information saved as session data

[0612] Step 7:

[0613] User:

[0614] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select an option such as "I am feeling stressed."

[0615] Input: Feeling stressed

[0616] Output: Emotional data sent to the terminal

[0617] Step 8:

[0618] Terminal:

[0619] The device sends emotional data to the server as an API request.

[0620] Input: User-entered sentiment data

[0621] Output: Sentiment data sent to the server

[0622] Step 9:

[0623] server:

[0624] The server analyzes the user's emotional state based on the received emotional data, and then generates recipes and menus that are appropriate for that state.

[0625] Input: Emotional data received from the device.

[0626] Output: Analyzed emotional state and suggested recipes based on it.

[0627] Step 10:

[0628] server:

[0629] The server searches its database for recipes based on the received ingredient information, conditions, and emotional data, and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[0630] Input: Ingredient information, condition information, emotion data

[0631] Output: Multiple recipes generated

[0632] Step 11:

[0633] server:

[0634] The server further filters the generated recipes based on specific criteria. For example, it can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[0635] Input: Multiple recipes

[0636] Output: Filtered recipes

[0637] Step 12:

[0638] server:

[0639] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on the filtered recipes.

[0640] Input: Filtered recipes

[0641] Output: Automatically generated menus for each period

[0642] Step 13:

[0643] server:

[0644] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[0645] Input: Automatically generated menu

[0646] Output: Menu and recipe details sent to the terminal

[0647] Step 14:

[0648] Terminal:

[0649] The device visually displays the received data within the application and provides it to the user. Specifically, it displays menus in a calendar format and provides an interface for viewing detailed information on each recipe.

[0650] Input: Menu and recipe details received from the server

[0651] Output: Visually displayed menu and recipe details

[0652] Step 15:

[0653] User:

[0654] Users review the provided menu and recipe details and prepare the dishes as needed.

[0655] Input: Visually displayed menu and recipe details

[0656] Output: Cooked food

[0657] Step 16:

[0658] User:

[0659] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[0660] Input: Cooked dishes, meal contents, calories, comments

[0661] Output: Meal data sent to the terminal

[0662] Step 17:

[0663] Terminal:

[0664] The terminal sends the entered meal data to the server as an API request.

[0665] Input: Meal data entered by the user

[0666] Output: Meal data sent to the server

[0667] Step 18:

[0668] server:

[0669] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any missing nutrients.

[0670] Input: Meal data received from the device

[0671] Output: Evaluation results and areas for improvement

[0672] Step 19:

[0673] server:

[0674] The server identifies areas for improvement based on the evaluation results and generates new improvement suggestions based on the user's preferences and health status. For example, it might suggest a menu with more salad the next day to compensate for a lack of vegetables.

[0675] Input: Evaluation result

[0676] Output: New improvement proposals

[0677] Step 20:

[0678] server:

[0679] Based on the improvement suggestions, the server generates a new menu and provides it to the user so they can try it the next day or the following week.

[0680] Input: Improvement suggestion

[0681] Output: Newly generated menu

[0682] Step 21:

[0683] Terminal:

[0684] The terminal displays improvement suggestions received from the server within the application and provides them to the user.

[0685] Input: Improvement suggestions received from the server

[0686] Output: Visually displayed improvement suggestions

[0687] Step 22:

[0688] User:

[0689] Users review the suggested improvements and incorporate them into their meals the following day or week.

[0690] Input: Visually displayed improvement suggestions

[0691] Output: Meal plan for the next day or next week

[0692] 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 user input for the result of the specific processing. The control unit 46A transmits the audio data indicating 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.

[0693] Data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of data generation model 58 is ChatGPT (registered trademark) (Internet search).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0694] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart device 14.

[0695] [Second Embodiment]

[0696] Figure 3 shows an example of the configuration of the data processing system 210 according to the second embodiment.

[0697] As shown in Figure 3, the data processing system 210 includes a data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0698] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0700] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

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

[0702] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0703] Figure 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Figure 4, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0704] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[0706] In the smart glasses 214, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0707] Next, the identification processing performed by the identification processing unit 290 of the data processing device 12 will be described. 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".

[0708] The system of this invention generates and provides menus and recipes based on ingredient information and conditions entered by the user. Furthermore, it supports the user's healthy eating habits by evaluating daily meal data and providing suggestions for improving their diet.

[0709] 1. Input and management of ingredient information

[0710] User

[0711] The user enters ingredient information (e.g., carrots, chicken, spinach) through the application's input form.

[0712] terminal

[0713] The entered ingredient information is sent to the server via an API request.

[0714] server

[0715] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[0716] 2. Selection and management of conditions

[0717] User

[0718] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese), allergens, and calorie restrictions in the application's form.

[0719] terminal

[0720] The selected conditions are sent to the server via an API request.

[0721] server

[0722] The received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[0723] 3. Recipe generation and filtering

[0724] server

[0725] Based on the received ingredient information and conditions, the system searches the database for recipes and generates multiple relevant recipes.

[0726] The generated recipes are filtered according to the user's criteria. For example, recipes can be filtered to include only Japanese cuisine, recipes that do not contain allergens, or recipes that meet calorie restrictions.

[0727] 4. Menu planning and serving

[0728] server

[0729] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week).

[0730] The generated menu and corresponding recipe details are sent to the device as an API response.

[0731] terminal

[0732] The received data is visually displayed within the application and provided to the user.

[0733] User

[0734] Review the provided menu and recipe details, and prepare the dishes as needed.

[0735] 5. Input and evaluation of daily meal data

[0736] User

[0737] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[0738] terminal

[0739] The entered meal data is sent to the server via an API request.

[0740] server

[0741] The system analyzes the received meal data to evaluate calorie intake, nutritional balance, and any nutritional deficiencies.

[0742] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on user preferences and health status.

[0743] 6. Providing suggestions for improvement

[0744] server

[0745] Based on the improvement suggestions, a new menu is generated and provided in a way that users can implement the next day or week.

[0746] terminal

[0747] The application displays improvement suggestions received from the server and provides them to the user.

[0748] User

[0749] We will implement the proposed improvements and enhance the quality of our diet.

[0750] Specific example

[0751] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates the optimal recipe based on this information and presents a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system evaluates the data and makes suggestions for necessary improvements. For example, if a user consumes a lot of "blanched spinach," the system might suggest "carrot tempura" the next day to balance the diet.

[0752] This invention allows users to easily maintain a balanced and healthy diet.

[0753] The following describes the processing flow.

[0754] Step 1: Enter ingredient information

[0755] User

[0756] Enter ingredient information into the application's input form. For example, enter specific ingredient names such as "carrots," "chicken," and "spinach."

[0757] terminal

[0758] The entered ingredient information is sent to the server as an API request.

[0759] Step 2: Selecting the conditions

[0760] User

[0761] You select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens (e.g., peanuts, wheat), and calorie restrictions (e.g., 1200 kcal / day) in the application form.

[0762] terminal

[0763] The selected conditions are sent to the server as an API request.

[0764] Step 3: Preservation and pre-processing of ingredient information and conditions

[0765] server

[0766] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalizing ingredient names, removing duplicates). Additionally, the received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[0767] Step 4: Recipe Generation

[0768] server

[0769] Based on the received ingredient information and conditions, the system searches the database for recipes and generates multiple relevant recipes. For example, if the condition is "Japanese food," only Japanese food recipes will be selected.

[0770] Step 5: Filtering Recipes

[0771] server

[0772] The generated recipes are then further filtered based on specific criteria. For example, you can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[0773] Step 6: Menu Generation

[0774] server

[0775] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[0776] Step 7: Provide menus and recipes

[0777] server

[0778] The generated menu and corresponding recipe details are sent to the device as an API response.

[0779] terminal

[0780] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[0781] User

[0782] Review the provided menu and recipe details, and prepare the dishes as needed.

[0783] Step 8: Enter meal data

[0784] User

[0785] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[0786] terminal

[0787] The entered meal data is sent to the server as an API request.

[0788] Step 9: Analysis and evaluation of dietary data

[0789] server

[0790] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[0791] Step 10: Generating improvement suggestions

[0792] server

[0793] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[0794] Step 11: Providing improvement suggestions

[0795] server

[0796] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[0797] terminal

[0798] The application displays improvement suggestions received from the server and provides them to the user.

[0799] User

[0800] Review the proposed improvements and incorporate them into your meals the following day or week.

[0801] By following the steps outlined above, users can maintain a healthy and balanced diet tailored to their individual needs.

[0802] (Example 1)

[0803] Next, we will describe Example 1. 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."

[0804] Traditional meal planning systems required users to manually create menus based on ingredients and other conditions, a cumbersome and time-consuming process. Furthermore, it was difficult to receive suggestions that considered nutritional balance and health conditions. In addition, there were virtually no suggestions for improving dietary habits based on daily meal data. This made it difficult for users to maintain healthy eating habits.

[0805] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0806] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for filtering the generated recipes using a generation AI model, means for receiving user-specified conditions, means for filtering recipes generated based on the conditions, means for automatically generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu and visually displaying them on the user terminal, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, and means for suggesting a new menu based on the areas for improvement. As a result, the user can visually confirm a balanced menu that is automatically generated based on the input ingredient information and specified conditions, and can also receive suggestions for improving their healthy eating habits based on their daily meal data.

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

[0808] A "recipe" is information that includes the steps and a list of ingredients for preparing a specific meal.

[0809] A "generative AI model" is a system or algorithm that uses artificial intelligence technology to generate relevant information from data.

[0810] "Conditions" refer to the constraints and requests that the user specifies when generating a recipe (e.g., type of dish, allergens, calorie restrictions).

[0811] "Filtering" is the process of selecting data based on specific criteria.

[0812] A "menu" is a set of meals planned for a specific period of time.

[0813] "Means of visual display" refers to a mechanism for displaying information graphically on a device.

[0814] "Meal data" refers to data in which users input details about their daily meals and the foods they consumed.

[0815] "Evaluating" is the process of analyzing and making judgments based on the input data.

[0816] "Areas for improvement" are elements that need to be changed or adjusted in order to improve one's diet.

[0817] To "propose" means to show methods or means for achieving a specific objective.

[0818] The system of the present invention generates and provides menus and recipes based on ingredient information and conditions entered by the user. Furthermore, it supports the user's healthy eating habits by evaluating daily meal data and providing suggestions for improving their diet. Specific embodiments are described below.

[0819] 1. Input and management of ingredient information

[0820] The user enters ingredient information (e.g., carrots, chicken, spinach) through the application's input form. At this time, they also enter the ingredient name, quantity, and other detailed information.

[0821] The terminal sends the entered ingredient information to the server via an API request. The terminal converts the input data into an appropriate format (e.g., JSON format) and sends it.

[0822] The server stores the received ingredient information in a database. It performs preprocessing such as normalizing ingredient names and removing duplicates so that "ninjin" and "ninjin" are recognized as the same ingredient.

[0823] 2. Selection and management of conditions

[0824] Users select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens, and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[0825] The device sends the selected conditions to the server via an API request. These conditions are treated as session data.

[0826] The server stores the received conditions as session data and uses them for recipe generation and filtering.

[0827] 3. Recipe generation and filtering

[0828] The server searches the database for recipe data and generates multiple candidate recipes based on the entered ingredient information and conditions. This generation process utilizes a generation AI model to produce highly accurate recipes.

[0829] The server filters recipes generated based on the user's criteria. Specifically, it selects recipes that are Japanese cuisine only, do not contain allergens, and are within calorie limits.

[0830] 4. Menu planning and serving

[0831] The server automatically generates meal plans for a specified period (e.g., 3 days, 1 week) based on filtered recipes. It combines menus suitable for each mealtime (breakfast, lunch, dinner).

[0832] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[0833] The device visually displays the received data within the application and provides it to the user. Details on how the user prepares each recipe are also displayed.

[0834] Users can view the displayed menu and recipe details, then prepare the meal. They can adjust the recipe as needed.

[0835] 5. Input and evaluation of daily meal data

[0836] Users input details about the dishes they actually prepared, the calories they consumed, and their impressions into the application.

[0837] The device sends the entered meal data to the server via an API request.

[0838] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any nutrient deficiencies (e.g., vitamins, minerals). If the user is not getting enough vitamin C, this information is recorded.

[0839] 6. Providing suggestions for improvement

[0840] Based on the analysis results, the server generates improvement suggestions that take into account the user's preferences and health condition. For example, if the user is deficient in vitamin C, it might suggest orange juice for breakfast the next day to compensate for the deficiency.

[0841] The server sends improvement suggestions to the terminal as an API response.

[0842] The device displays the received improvement suggestions within the application and provides them to the user.

[0843] Users implement the suggested improvements and enhance the quality of their diet.

[0844] Specific example

[0845] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates an optimal recipe based on this information. A three-day menu is presented, and the user prepares meals according to it. After that, the system analyzes the meal data entered and balances the diet by suggesting "carrot tempura" for the next day.

[0846] Examples of prompts for generative AI models

[0847] If a user enters "carrots," "chicken," and "spinach," and selects the conditions "Japanese cuisine," "no allergies," and "1200 kcal / day calorie restriction," please generate a 3-day meal plan. Also, please include meal suggestions for the following day to ensure balance.

[0848] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0849] Step 1:

[0850] The user enters ingredient information (e.g., carrots, chicken, spinach) into the application's input form.

[0851] Input: Ingredient information entered by the user.

[0852] Output: Ingredient information is temporarily stored within the application.

[0853] Specific operation: When the user enters text into the form and presses the confirmation button, the information proceeds to the next step.

[0854] Step 2:

[0855] The terminal sends the entered ingredient information to the server via an API request.

[0856] Input: Ingredient information entered in Step 1.

[0857] Output: Ingredient information is sent to the server.

[0858] Specific operation: The terminal converts the entered ingredient information into JSON format and sends an HTTP POST request to the API endpoint.

[0859] Step 3:

[0860] The server stores the received ingredient information in a database.

[0861] Input: Ingredient information sent from the device.

[0862] Output: Ingredient information is saved in the database.

[0863] Specific operation: The server saves the received data to the appropriate table in the database using an INSERT statement, and performs normalization and duplicate removal of ingredient names as needed.

[0864] Step 4:

[0865] Users select conditions such as the type of cuisine (Japanese, Western, or Chinese), allergens, and calorie restrictions in an input form.

[0866] Input: User-selected criteria information.

[0867] Output: Condition information is temporarily stored within the application.

[0868] Specific operation: When the user selects conditions using a dropdown menu or checkboxes and presses the confirmation button, the information proceeds to the next step.

[0869] Step 5:

[0870] The device sends the selected conditions to the server via an API request.

[0871] Input: Condition information entered in Step 4.

[0872] Output: Condition information is sent to the server.

[0873] Specific operation: The terminal converts the selected conditions into JSON format and sends an HTTP POST request to the API endpoint.

[0874] Step 6:

[0875] The server stores the received conditions as session data and uses them for subsequent recipe generation and filtering.

[0876] Input: Conditional information sent from the terminal.

[0877] Output: Condition information is saved to the server as session data.

[0878] Specific operation: The server stores the received data in memory as session data and also backs it up in the database.

[0879] Step 7:

[0880] The server searches the database for recipe data and generates multiple candidate recipes based on the entered ingredient information and conditions. This generation process utilizes a generation AI model.

[0881] Input: Recipe data, ingredient information, and condition information from the database.

[0882] Output: Multiple candidate recipes are generated.

[0883] Specific operation: Using a generative AI model, ingredient information and condition information are provided as input, and highly relevant recipes are generated. The generated recipes are temporarily stored in memory.

[0884] Step 8:

[0885] The server filters the recipes generated based on the user's criteria.

[0886] Input: Multiple generated candidate recipes, user criteria information.

[0887] Output: Filtered list of recipes.

[0888] Specific operation: The server uses conditional information to filter candidate recipes, selecting those that are Japanese cuisine only, do not contain allergens, or are within calorie limits.

[0889] Step 9:

[0890] The server automatically generates meal plans for a specified period (e.g., 3 days, 1 week) based on the filtered recipes.

[0891] Input: Filtered list of recipes.

[0892] Output: Automatically generated menu for the specified period.

[0893] Specific operation: The server generates balanced menus by combining menus suitable for each mealtime (breakfast, lunch, and dinner), making it easy for the user to prepare them.

[0894] Step 10:

[0895] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[0896] Input: Automatically generated menu and its details.

[0897] Output: Menu and recipe details sent to the device as an API response.

[0898] Specific operation: The server converts the generated menu and recipe details into JSON format and sends it as an HTTP response to the appropriate API endpoint.

[0899] Step 11:

[0900] The device visually displays the received data within the application.

[0901] Input: Menu and recipe details sent from the server.

[0902] Output: Menu and recipe details displayed visually within the application.

[0903] Specific operation: The terminal parses the received JSON data and visually formats it using HTML and CSS to display it in the user interface.

[0904] Step 12:

[0905] Users review the provided menu and recipe details and then prepare the dishes.

[0906] Input: Displayed menu and recipe details.

[0907] Output: Confirmed menu and prepared dishes.

[0908] Specific actions: The user checks the recipe details displayed on the screen and then actually prepares the dish.

[0909] Step 13:

[0910] Users input details about the dishes they actually prepared, the calories they consumed, and their impressions into the application.

[0911] Input: Details of the meals actually consumed.

[0912] Output: Input meal data.

[0913] Specific operation: The user enters detailed information into the input form and presses the submit button to advance the data to the next step.

[0914] Step 14:

[0915] The device sends the entered meal data to the server via an API request.

[0916] Input: Meal data entered by the user.

[0917] Output: Meal data sent to the server.

[0918] Specific operation: The device converts the meal data into JSON format and sends it to the appropriate API endpoint via an HTTP POST request.

[0919] Step 15:

[0920] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any missing nutrients.

[0921] Input: Meal data entered by the user.

[0922] Output: Evaluation results (calorie intake, nutritional balance, deficient nutrients, etc.).

[0923] Specific operation: The server analyzes the received meal data, calculates the daily nutrient intake, evaluates the nutritional balance, and identifies any deficient nutrients.

[0924] Step 16:

[0925] The server generates improvement suggestions based on the evaluation results, taking into account the user's preferences and health condition.

[0926] Input: Evaluated meal data, user preferences, and health status.

[0927] Output: Improvement suggestions.

[0928] Specific operation: The server suggests the content and menu of meals for the next day, based on evaluation results and the user's past eating history. For example, if the user is deficient in vitamin C, it will suggest orange juice for breakfast.

[0929] Step 17:

[0930] The server sends improvement suggestions to the terminal as an API response.

[0931] Input: Generated improvement suggestions.

[0932] Output: Improvement suggestions sent to the terminal as an API response.

[0933] Specific operation: The server converts the improvement suggestions into JSON format and sends them as an HTTP response to the appropriate API endpoint.

[0934] Step 18:

[0935] The device displays the received improvement suggestions within the application.

[0936] Input: Improvement suggestions sent from the server.

[0937] Output: Improvement suggestions visually displayed within the application.

[0938] Specific operation: The terminal parses the received JSON data and visually formats it using HTML and CSS to display it in the user interface.

[0939] Step 19:

[0940] Users implement the suggested improvements and enhance the quality of their diet.

[0941] Input: Displayed improvement suggestions.

[0942] Output: Improved eating habits as a result of implementing the proposed improvements.

[0943] Specific actions: Users maintain a healthy diet by preparing ingredients according to the displayed improvement suggestions and incorporating them into their next meal.

[0944] (Application Example 1)

[0945] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0946] In modern society, maintaining a healthy diet amidst a busy lifestyle is a challenging task. Furthermore, creating nutritionally balanced meal plans is time-consuming, highlighting the need for a user-friendly system. Additionally, there is a lack of economic incentives to encourage the purchase of healthy ingredients. Therefore, a system is needed that provides optimal recipes and meal plans based on ingredient information, and also offers cashback to further promote the purchase of healthy ingredients.

[0947] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0948] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, means for proposing a new menu based on the areas for improvement, and means for providing cashback when healthy ingredients are purchased based on the new menu. As a result, the user can easily maintain a balanced diet while also gaining an incentive to purchase healthy ingredients, thus enjoying both health maintenance and improvement and economic convenience at the same time.

[0949] "Means for receiving ingredient information" refers to the methods or devices used by the system to receive data on the type and quantity of ingredients entered by the user.

[0950] "Means for generating multiple recipes based on received ingredient information" refers to algorithms or programs that suggest multiple recipes for corresponding dishes based on the input ingredient information.

[0951] "Means for presenting a selected recipe from the recipes generated by the recipe generation means" refers to a method or interface for displaying a specific recipe to a user from among multiple generated recipes.

[0952] "Means for receiving user-specified conditions" refers to methods and functions for receiving conditions such as the type of cuisine, allergy information, and calorie restrictions as input from the user.

[0953] "Means for filtering recipes generated based on conditions" refers to algorithms or programs that narrow down the generated recipes by taking into account the conditions specified by the user.

[0954] "Methods for generating menus based on filtered recipes" refers to methods or programs for creating meal plans (menus) for a certain period of time using filtered recipes.

[0955] "Means of providing recipes corresponding to a menu" refers to methods or functions for providing users with specific recipes for dishes based on a created menu.

[0956] "Means for users to input daily meal data" refers to interfaces or devices that allow users to input details of the meals they actually consumed into the system.

[0957] "Methods for evaluating meal data and identifying areas for improvement" refer to algorithms and programs that analyze input meal data and identify areas for improvement from perspectives such as nutritional balance and calorie intake.

[0958] "Methods for suggesting new menus based on areas for improvement" refers to methods or programs for suggesting new meal plans (menus) to users, taking into account identified areas for improvement.

[0959] A "method of providing cashback for purchasing healthy ingredients based on a new menu" refers to a system or service that provides users with an economic incentive (cashback) by purchasing ingredients included in a suggested menu.

[0960] To implement this invention, the following system configuration and program are used.

[0961] System Configuration

[0962] Hardware and software

[0963] Server: Flask (Python), MySQL or PostgreSQL, scikit-learn, TensorFlow

[0964] User device: Smartphone application (Android / iOS)

[0965] System Operation Description

[0966] Input and management of ingredient information

[0967] The user enters ingredient information (e.g., carrots, chicken, spinach) through an input form in a smartphone application. The application sends this information to the server as an API request, and the server stores the received ingredient information in a database. The stored data is preprocessed (e.g., normalization of ingredient names, removal of duplicates).

[0968] Selection and management of conditions

[0969] Users can select the type of dish, allergy information, calorie restrictions, etc., through the application's form. These conditions are sent to the server via API requests and temporarily stored as session data. This data is then used for subsequent recipe generation and filtering.

[0970] Recipe generation and filtering

[0971] The server generates multiple relevant recipes using a generative AI model based on the received ingredient information and conditions. It then filters the recipes based on these conditions, for example, selecting only Japanese cuisine, recipes that do not contain allergens, or recipes within calorie limits.

[0972] Menu planning and serving

[0973] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). The generated meal plans and corresponding recipe details are sent to the device as an API response, allowing the user to visually confirm them within the application.

[0974] Input and evaluation of daily meal data

[0975] Users input details about the dishes they have cooked, the meals they have eaten, the calorie content, and their impressions into the application. The application sends this data to a server, which analyzes the received data to evaluate calorie intake and nutritional balance, and identifies any nutrient deficiencies.

[0976] Providing improvement suggestions

[0977] Based on the evaluation results, the system generates improvement suggestions that take into account the user's preferences and health condition, and proposes new menus. Furthermore, it provides a system where users can receive cashback when purchasing specific healthy ingredients.

[0978] Specific example

[0979] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates an optimal recipe based on this information and presents a three-day meal plan. When the user prepares meals according to this plan and inputs the meal data, the system evaluates the data and makes suggestions for necessary improvements. For example, if a user consumes a lot of "blanched spinach," the system might suggest "carrot tempura" the next day to balance it out. In addition, a system is implemented that offers cashback when users purchase these ingredients, supporting the maintenance of a healthy diet for users.

[0980] Example of a prompt

[0981] Please suggest Japanese recipes using carrots, chicken, and spinach. The calorie limit is 1200 kcal / day. There is no allergy information.

[0982] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0983] Step 1:

[0984] The user enters ingredient information (e.g., carrots, chicken, spinach) through an input form in the smartphone application. Once the user has finished entering the information, the application formats this ingredient information in JSON format and sends it to the server via an API request. The server saves the received ingredient information to a database and performs pre-processing such as normalizing ingredient names and removing duplicates before saving. In this step, the input is the ingredient information entered by the user, and the output is the saving of the pre-processed ingredient information to the database.

[0985] Step 2:

[0986] The user selects individual conditions such as the type of dish, allergy information, and calorie restrictions through a form in the smartphone application. Once the user has made their selections, the application formats these conditions in JSON format and sends them to the server via an API request. The server temporarily stores the received condition data as session data and uses it for subsequent recipe generation and filtering processes. The input for this step is the condition data selected by the user, and the output is the storage of the session data.

[0987] Step 3:

[0988] The server generates multiple recipes using a generative AI model based on ingredient information and condition data stored in the database. The AI ​​model utilizes the input ingredient information to extract and generate relevant recipes from the corresponding recipe database. The generated recipes are temporarily stored in a cache. The input for this step is ingredient information and condition data, and the output is the generated recipe data.

[0989] Step 4:

[0990] The server filters the generated recipe data based on conditional data. For example, it extracts only recipes that meet the user's criteria, such as Japanese food only, recipes that do not contain allergens, or recipes that are within calorie limits. The filtered recipe data is then stored in the cache again. The input for this step is the generated recipe data and conditional data, and the output is the filtered recipe data.

[0991] Step 5:

[0992] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on the filtered recipes. The generated meal plans and corresponding recipe details are sent to the user's device as an API response. The user can visually view these meal plans and recipe details within the application. The input for this step is filtered recipe data and a specified period, and the output is the generated meal plan data.

[0993] Step 6:

[0994] Users input details such as the dishes they actually prepared, the meals they ate, calories, and their impressions into a smartphone application. The application formats this meal data in JSON format and sends it to the server via an API request. The server analyzes the received meal data, evaluates calorie intake and nutritional balance, and identifies any deficient nutrients. The input for this step is the meal data entered by the user, and the output is the evaluation result data.

[0995] Step 7:

[0996] The server generates improvement suggestions based on the evaluation results, taking into account the user's preferences and health status. It automatically generates a new menu based on the suggested improvements and provides it in a way that the user can implement the next day or week. Furthermore, the application displays a mechanism offering a cashback incentive for purchasing healthy ingredients based on this new menu. The input for this step is the evaluation result data, and the output is the improvement suggestions and cashback information.

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

[0998] This invention is a system that recognizes the user's emotions in addition to the ingredient information and conditions entered by the user, and generates and provides recipes and menus based on those emotions. This system not only improves the quality of the user's diet but also supports a healthier and more satisfying diet by taking into account the user's emotional state.

[0999] 1. Input and management of ingredient information

[1000] User

[1001] The user enters ingredient information into the application's input form. For example, they might enter specific ingredients such as "carrots," "chicken," or "spinach."

[1002] terminal

[1003] The entered ingredient information is sent to the server via an API request.

[1004] server

[1005] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[1006] 2. Selection and management of conditions

[1007] User

[1008] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens (e.g., peanuts, wheat, etc.), and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[1009] terminal

[1010] The selected conditions are sent to the server via an API request.

[1011] server

[1012] The received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[1013] 3. Utilizing the Emotion Engine

[1014] User

[1015] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select options such as "feeling stressed," "feeling happy," or "feeling tired."

[1016] terminal

[1017] The emotional data is sent to the server as an API request.

[1018] server

[1019] Based on the received emotional data, the system analyzes the user's emotional state and generates recipes and menus that are appropriate for that state.

[1020] 4. Recipe generation and filtering

[1021] server

[1022] Based on the received ingredient information, conditions, and emotional data, the system searches the database for recipes and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[1023] server

[1024] The generated recipes are then further filtered based on specific criteria. For example, you can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[1025] 5. Menu creation and provision

[1026] server

[1027] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[1028] server

[1029] The generated menu and corresponding recipe details are sent to the device as an API response.

[1030] terminal

[1031] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[1032] User

[1033] Review the provided menu and recipe details, and prepare the dishes as needed.

[1034] 6. Input and evaluation of daily meal data

[1035] User

[1036] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[1037] terminal

[1038] The entered meal data is sent to the server as an API request.

[1039] server

[1040] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[1041] 7. Generating and providing improvement suggestions

[1042] server

[1043] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[1044] server

[1045] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[1046] terminal

[1047] The application displays improvement suggestions received from the server and provides them to the user.

[1048] User

[1049] Review the proposed improvements and incorporate them into your meals the following day or week.

[1050] Specific example

[1051] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and also inputs their emotional state as "feeling stressed," the server will generate an optimal recipe based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system will evaluate the data and make suggestions for necessary improvements. For example, if the user consumes a lot of "blanched spinach, which has a relaxing effect," the system will balance this by suggesting "glazed carrots, which help reduce stress," on the next day.

[1052] This invention allows users to easily achieve a healthy and balanced diet tailored to their individual circumstances and emotional state.

[1053] The following describes the processing flow.

[1054] Step 1: Enter ingredient information

[1055] User

[1056] Enter ingredient information into the application's input form. For example, enter specific ingredients such as "carrots," "chicken," and "spinach."

[1057] terminal

[1058] The entered ingredient information is sent to the server as an API request.

[1059] Step 2: Selecting the conditions

[1060] User

[1061] You select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens (e.g., peanuts, wheat), and calorie restrictions (e.g., 1200 kcal / day) in the application form.

[1062] terminal

[1063] The selected conditions are sent to the server as an API request.

[1064] Step 3: Preservation and pre-processing of ingredient information and conditions

[1065] server

[1066] The received ingredient information and conditions are saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[1067] Step 4: Entering emotional data

[1068] User

[1069] The application allows users to input or recognize their current emotional state through an emotion input form or emotion recognition function. For example, they can choose from options such as "feeling stressed," "feeling happy," or "feeling tired."

[1070] terminal

[1071] The emotional data is sent to the server as an API request.

[1072] Step 5: Saving and analyzing emotional data

[1073] server

[1074] The received emotional data is stored in a database and analyzed. This allows for the identification of appropriate recipes and menus based on the user's emotional state.

[1075] Step 6: Recipe Generation

[1076] server

[1077] Based on the received ingredient information, conditions, and emotional data, the system searches the database for recipes and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[1078] Step 7: Filtering Recipes

[1079] server

[1080] The generated recipes are then filtered based on specific criteria. For example, recipes can be narrowed down by conditions such as "does not contain allergens" or "is within calorie limits."

[1081] Step 8: Menu Generation

[1082] server

[1083] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[1084] Step 9: Provide menus and recipes

[1085] server

[1086] The generated menu and corresponding recipe details are sent to the device as an API response.

[1087] terminal

[1088] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[1089] User

[1090] Review the provided menu and recipe details, and prepare the dishes as needed.

[1091] Step 10: Enter meal data

[1092] User

[1093] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[1094] terminal

[1095] The entered meal data is sent to the server as an API request.

[1096] Step 11: Analysis and evaluation of dietary data

[1097] server

[1098] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[1099] Step 12: Generating improvement suggestions

[1100] server

[1101] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[1102] Step 13: Providing improvement suggestions

[1103] server

[1104] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[1105] terminal

[1106] The application displays improvement suggestions received from the server and provides them to the user.

[1107] User

[1108] Review the proposed improvements and incorporate them into your meals the following day or week.

[1109] By following the steps outlined above in sequence, users can maintain a healthy and balanced diet tailored to their individual circumstances and emotional state.

[1110] (Example 2)

[1111] Next, we will describe Example 2. 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".

[1112] In modern life, balancing health and diet is becoming increasingly important. However, it is extremely difficult for users to manage daily ingredient selection, recipe planning, and meal planning tailored to their emotional state all at once. In particular, excluding allergens, restricting calories, and simultaneously suggesting menus based on the user's emotions and health condition are challenging with current systems. Furthermore, features that evaluate daily meal data and suggest improvements are generally lacking. An efficient system is needed to solve these problems.

[1113] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[1114] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, means for proposing a new menu based on the areas for improvement, means for inputting or recognizing the user's emotional state, and means for analyzing the emotional state and generating recipes and menus based thereon. As a result, the user can centrally manage ingredient selection, recipe selection, and menu creation tailored to their emotional state in their daily diet, and also receive improvement suggestions according to their health condition.

[1115] "Ingredient information" refers to the specific names of ingredients entered by the user, and indicates the ingredients used in the dish.

[1116] A "recipe generation method" refers to a device or program that has the function of generating a series of cooking procedures and ingredient combinations based on the received ingredient information.

[1117] A "recipe presentation means" refers to a device or program that selects and displays a recipe to be presented to the user from among the recipes generated by the recipe generation means.

[1118] "Conditions" refer to individual requirements specified by the user, such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens, and calorie restrictions.

[1119] A "filtering device" refers to a device or program that selects recipes that match specified conditions from among the generated recipes.

[1120] A "menu generation method" refers to a device or program that automatically assembles a menu for a period specified by the user, based on filtered recipes.

[1121] A "recipe provisioning means" refers to a device or program that provides users with detailed information on the generated menu and its corresponding recipe.

[1122] "Meal data" refers to information about the user's daily meals, including the type of food consumed, calories, and comments.

[1123] "Evaluation means" refers to devices or programs that analyze received meal data and evaluate information such as calorie intake and nutritional balance.

[1124] "Improvement suggestion means" refers to devices or programs that propose new menus based on the areas for improvement identified by the evaluation means.

[1125] "Emotional state" refers to the user's current mental state as input or perceived (for example, feeling stressed, happy, tired, etc.).

[1126] "Emotional analysis means" refers to devices or programs that analyze the emotional state received and generate recipes or menus based on the user's emotions and mood.

[1127] This invention is a system that recognizes the user's emotional state in addition to the ingredient information and conditions entered by the user, and generates and provides recipes and menus based on that. This system not only improves the quality of the user's diet but also supports a healthier and more satisfying diet by taking into account the user's emotional state.

[1128] The implementation of this invention is realized through devices and software that have three main roles: server, terminal, and user.

[1129] server

[1130] The server includes a database (e.g., MySQL, PostgreSQL) for receiving, storing, and pre-processing ingredient information, as well as programs for recipe generation, filtering, sentiment analysis, and menu generation. It is also responsible for evaluating received meal data and generating improvement suggestions. The server also includes an interface for communicating with terminals via API requests.

[1131] terminal

[1132] The terminal provides an input form for the user and sends information such as ingredient information, conditions, emotional state, and meal data to the server as an API request. It also visualizes and provides the user with recipes, menus, and improvement suggestions received from the server. The terminal can be implemented on a variety of devices, including smartphones, tablets, and personal computers.

[1133] User

[1134] Users input ingredient information, conditions, emotional state, and meal data through their device. Furthermore, they utilize the system by creating dishes based on provided recipes and menus, and then inputting data on the meals they actually consumed.

[1135] As a concrete example, if a user uses "carrots," "chicken," and "spinach," sets the conditions of "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and enters "feeling stressed" as their emotional state, the server will generate recipes based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and enters the meal data, the system will analyze the data and, the following day, offer suggestions for improvement, such as "glazed carrots to help reduce stress."

[1136] Examples of prompt statements are as follows:

[1137] "If a user wants to make Japanese food using carrots, chicken, and spinach, what should they do?"

[1138] "Please generate a meal plan suitable for a user who has no allergies, desires a calorie restriction of 1200 kcal / day, and is also experiencing stress."

[1139] This invention allows users to efficiently select ingredients, decide on recipes, and create menus tailored to their emotional state, while also receiving suggestions for improvements based on their health condition. This system contributes to improving the quality of diet and increasing user satisfaction.

[1140] The flow of the specific processing in Example 2 will be explained using Figure 13.

[1141] Step 1:

[1142] The user enters ingredient information. The user enters specific ingredients such as "carrots," "chicken," and "spinach" into the application's input form. The entered ingredient information is sent to the device.

[1143] Step 2:

[1144] The terminal sends ingredient information to the server. The entered ingredient information is sent to the server in the form of an API request. The communication protocol used is HTTP / HTTPS. The input data is often encoded in JSON format.

[1145] Step 3:

[1146] The server stores and preprocesses the ingredient information. The received ingredient information is stored in a database (e.g., MySQL, PostgreSQL). Then, data preprocessing is performed, such as normalizing ingredient names (e.g., unifying "ninjin" to "ninjin") and removing duplicates. The output is formatted ingredient information.

[1147] Step 4:

[1148] The user selects the conditions. The user enters conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens, and calorie restrictions (e.g., 1200 kcal / day) into the application's form. The entered data is saved on the device.

[1149] Step 5:

[1150] The device sends the conditions to the server. The selected conditions are sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the condition data is encoded in JSON format.

[1151] Step 6:

[1152] The server saves the conditions. The received condition data is saved as session data and used for subsequent recipe generation and filtering. The condition data is saved as session data as output.

[1153] Step 7:

[1154] The user inputs emotional data. They use an emotional input form or emotional recognition function to enter their current emotional state (e.g., "feeling stressed"). The emotional data is saved on the device.

[1155] Step 8:

[1156] The device sends emotional data to the server. The emotional data is sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the emotional data is encoded in JSON format.

[1157] Step 9:

[1158] The server analyzes the emotional data. It analyzes the received emotional data to understand the user's emotional state. The analysis is performed using NLP (Natural Language Processing) libraries (e.g., NLTK, spaCy) and emotion analysis models. As a result of the analysis, tags and scores corresponding to the emotional state are obtained.

[1159] Step 10:

[1160] The server generates and filters recipes. It searches the recipe database based on received ingredient information, conditions, and sentiment data, generating multiple relevant recipes. Furthermore, it filters the recipes based on conditions such as "does not contain allergens" and "is within calorie limits." The output is a filtered list of recipes.

[1161] Step 11:

[1162] The server generates a menu and sends it to the terminal. Based on the filtered recipes, it automatically generates a menu for the period specified by the user. The generated menu and recipe details are sent to the terminal as an API response. Menu data is obtained as output.

[1163] Step 12:

[1164] The device displays the menu. The received menu and recipe details are visually displayed within the application. This can be done in a calendar format, and detailed information for each recipe can be viewed with a click. The user reviews this information and prepares the meal.

[1165] Step 13:

[1166] The user inputs meal data. They enter details such as the dishes they actually prepared, the meals they ate, calories, and their impressions into the application. The meal data is saved on the device.

[1167] Step 14:

[1168] The device sends meal data to the server. The entered meal data is sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the meal data is encoded in JSON format.

[1169] Step 15:

[1170] The server analyzes and evaluates the meal data. It analyzes the received meal data and evaluates factors such as calorie intake and nutritional balance. It checks whether specific nutrients are deficient or excessive. The evaluation results are provided as output.

[1171] Step 16:

[1172] The server generates improvement suggestions and sends them to the terminal. Based on the evaluation results, it identifies areas for improvement and generates new improvement suggestions based on the user's preferences and health status. The generated improvement suggestions are sent to the terminal as an API response. The output is improvement suggestion data.

[1173] Step 17:

[1174] The device displays improvement suggestions. Received improvement suggestions are displayed within the application. The user reviews them and incorporates them into their meals for the following day or week.

[1175] (Application Example 2)

[1176] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[1177] Traditional recipe suggestion systems propose recipes based on ingredients and conditions specified by the user. However, this fails to consider the user's emotional state, resulting in meal suggestions that may not be suitable for the user's current mood or health condition. Furthermore, they often lack the functionality to automatically generate menus for multiple days and order ingredients in bulk based on those menus. In addition, they are insufficient in utilizing data on meals actually prepared by the user to provide continuous healthy meal suggestions.

[1178] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for recognizing the user's emotional state, means for optimizing the recipes based on the emotional state, means for automatically generating a menu based on the filtered recipes and presenting menus for each period, means for ordering meals based on the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, and means for proposing a new menu based on the areas for improvement. This makes it possible to propose recipes and menus that take into account the user's emotional state, thereby supporting a healthy and satisfying diet. Furthermore, by providing a function to order ingredients in bulk based on the automatically generated menu, the user's workload can be reduced.

[1179] "Means for receiving ingredient information" refers to an interface that allows the system to receive ingredient information entered by the user and send it to the server.

[1180] "Means for generating multiple recipes" refers to algorithms and processes for searching a database for and generating multiple recipes based on the received ingredient information.

[1181] "A means of presenting a recipe selected from a list of recipes" refers to an interface for presenting the user with the most suitable recipe from among those that have been generated.

[1182] "Means for receiving user-specified conditions" refers to an interface that allows the system to receive conditions entered by the user, such as the type of food, allergy information, and calorie restrictions, and send them to the server.

[1183] "Means for filtering recipes generated based on conditions" refers to algorithms and processes for selecting appropriate recipes based on conditions specified by the user.

[1184] "Means for generating menus" refers to algorithms and processes for automatically generating menus for a specified period by combining selected recipes.

[1185] "Means of providing recipes corresponding to menus" refers to an interface for providing users with generated menus and their corresponding recipes.

[1186] "Means for recognizing the user's emotional state" refers to an input interface and emotion analysis algorithm that the system uses to recognize the user's current emotional state (e.g., stress, happiness, fatigue).

[1187] "Means for optimizing the recipe based on emotional state" refers to an algorithm and process for selecting and suggesting the most suitable recipe to the user, taking into account the recognized emotional state.

[1188] "A means of automatically generating menus and presenting them for each period" refers to an interface that automatically generates menus for a period specified by the user (e.g., 3 days, 1 week) and presents them to the user in a calendar format.

[1189] "A means of ordering meals based on a menu" refers to an interface for ordering specific meals as a food delivery service based on a generated menu.

[1190] "A means of inputting daily meal data" refers to an interface for users to input data into the system, such as the content of meals they actually ate, calories, and their impressions.

[1191] "Methods for evaluating dietary data and identifying areas for improvement" refers to algorithms and processes for analyzing input dietary data, evaluating nutritional balance and calorie intake, and identifying areas for improvement.

[1192] "Methods for suggesting new menus based on areas for improvement" refers to algorithms and processes for suggesting new menus to users based on identified areas for improvement.

[1193] In order to implement this invention, the main components—the server, terminal, and user—must function in coordination. The following describes a specific system embodiment and its processing.

[1194] 1. Input and management of ingredient information

[1195] User:

[1196] The user enters ingredient information into the application's input form. For example, they might enter specific ingredient information such as "carrots," "chicken," and "spinach."

[1197] Terminal:

[1198] The terminal sends the entered ingredient information to the server via an API request.

[1199] server:

[1200] The server stores the received ingredient information in a database and performs preprocessing as needed, such as normalizing ingredient names and removing duplicates.

[1201] 2. Selection and management of conditions

[1202] User:

[1203] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens (e.g., peanuts, wheat, etc.), and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[1204] Terminal:

[1205] The device sends the selected conditions to the server via an API request.

[1206] server:

[1207] The server temporarily stores the received conditions as session data and uses them for subsequent recipe generation and filtering.

[1208] 3. Utilizing the Emotion Engine

[1209] User:

[1210] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select options such as "feeling stressed," "feeling happy," or "feeling tired."

[1211] Terminal:

[1212] The device sends emotional data to the server as an API request.

[1213] server:

[1214] The server analyzes the user's emotional state based on the received emotional data and generates recipes and menus that are appropriate for that state.

[1215] 4. Recipe generation and filtering

[1216] server:

[1217] The server searches its database for recipes based on the received ingredient information, conditions, and emotional data, and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[1218] server:

[1219] The server further filters the generated recipes based on specific criteria. For example, it can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[1220] 5. Menu creation and provision

[1221] server:

[1222] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on filtered recipes. For example, it might combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[1223] server:

[1224] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[1225] Terminal:

[1226] The device visually displays the received data within the application and provides it to the user. Specifically, it can display menus in a calendar format and allow users to view detailed information about each recipe with a click.

[1227] User:

[1228] Users review the provided menu and recipe details and prepare the dishes as needed.

[1229] 6. Input and evaluation of daily meal data

[1230] User:

[1231] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[1232] Terminal:

[1233] The terminal sends the entered meal data to the server as an API request.

[1234] server:

[1235] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[1236] 7. Generating and providing improvement suggestions

[1237] server:

[1238] The server identifies areas for improvement based on the evaluation results and generates new improvement suggestions based on the user's preferences and health status. For example, it might suggest a menu with more salad the next day to compensate for a lack of vegetables.

[1239] server:

[1240] Based on the improvement suggestions, the server generates a new menu and provides it to the user so they can try it the next day or the following week.

[1241] Terminal:

[1242] The terminal displays improvement suggestions received from the server within the application and provides them to the user.

[1243] User:

[1244] Users review the suggested improvements and incorporate them into their meals the following day or week.

[1245] Specific example

[1246] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and also inputs their emotional state as "feeling stressed," the server will generate an optimal recipe based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system will evaluate the data and provide suggestions for necessary improvements. For example, on a day when the user has consumed a lot of "blanched spinach, which has a relaxing effect," the system may suggest "glazed carrots, which help reduce stress," on the next day to balance things out.

[1247] Example of a prompt:

[1248] "Today's ingredients are carrots and chicken, but I'm feeling stressed. Please suggest a relaxing Japanese recipe under 1200 kcal."

[1249] Thus, the system of this invention is designed to take into account the user's emotional state and support a healthy and satisfying diet. Furthermore, by providing a function to order ingredients in bulk based on automatically generated menus, it reduces the effort required of the user.

[1250] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1251] Step 1:

[1252] User:

[1253] The user enters food information into the application's input form. For example, they enter specific ingredients such as "carrots," "chicken," and "spinach." The entered food information is then sent to the device.

[1254] Input: carrots, chicken, spinach

[1255] Output: Ingredient information sent to the terminal

[1256] Step 2:

[1257] Terminal:

[1258] The terminal sends the entered ingredient information to the server via an API request.

[1259] Input: Ingredient information entered by the user

[1260] Output: Ingredient information sent to the server

[1261] Step 3:

[1262] server:

[1263] The server stores the received ingredient information in a database. Before saving, it performs preprocessing such as normalizing ingredient names and removing duplicates.

[1264] Input: Food ingredient information received from the terminal

[1265] Output: Normalized and deduplication-removed database entries

[1266] Step 4:

[1267] User:

[1268] Users select conditions such as the type of cuisine, allergens, and calorie restrictions through the application's form.

[1269] Input: Japanese food, no allergies, 1200 kcal / day

[1270] Output: Condition information sent to the terminal

[1271] Step 5:

[1272] Terminal:

[1273] The device sends the selected condition information to the server via an API request.

[1274] Input: User-selected condition information

[1275] Output: Condition information sent to the server

[1276] Step 6:

[1277] server:

[1278] The server temporarily stores the received condition information as session data and uses it for subsequent recipe generation and filtering.

[1279] Input: Conditional information received from the device

[1280] Output: Condition information saved as session data

[1281] Step 7:

[1282] User:

[1283] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select an option such as "I am feeling stressed."

[1284] Input: Feeling stressed

[1285] Output: Emotional data sent to the terminal

[1286] Step 8:

[1287] Terminal:

[1288] The device sends emotional data to the server as an API request.

[1289] Input: User-entered sentiment data

[1290] Output: Sentiment data sent to the server

[1291] Step 9:

[1292] server:

[1293] The server analyzes the user's emotional state based on the received emotional data, and then generates recipes and menus that are appropriate for that state.

[1294] Input: Emotional data received from the device.

[1295] Output: Analyzed emotional state and suggested recipes based on it.

[1296] Step 10:

[1297] server:

[1298] The server searches its database for recipes based on the received ingredient information, conditions, and emotional data, and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[1299] Input: Ingredient information, condition information, emotion data

[1300] Output: Multiple recipes generated

[1301] Step 11:

[1302] server:

[1303] The server further filters the generated recipes based on specific criteria. For example, it can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[1304] Input: Multiple recipes

[1305] Output: Filtered recipes

[1306] Step 12:

[1307] server:

[1308] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on the filtered recipes.

[1309] Input: Filtered recipes

[1310] Output: Automatically generated menus for each period

[1311] Step 13:

[1312] server:

[1313] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[1314] Input: Automatically generated menu

[1315] Output: Menu and recipe details sent to the terminal

[1316] Step 14:

[1317] Terminal:

[1318] The device visually displays the received data within the application and provides it to the user. Specifically, it displays menus in a calendar format and provides an interface for viewing detailed information on each recipe.

[1319] Input: Menu and recipe details received from the server

[1320] Output: Visually displayed menu and recipe details

[1321] Step 15:

[1322] User:

[1323] Users review the provided menu and recipe details and prepare the dishes as needed.

[1324] Input: Visually displayed menu and recipe details

[1325] Output: Cooked food

[1326] Step 16:

[1327] User:

[1328] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[1329] Input: Cooked dishes, meal contents, calories, comments

[1330] Output: Meal data sent to the terminal

[1331] Step 17:

[1332] Terminal:

[1333] The terminal sends the entered meal data to the server as an API request.

[1334] Input: Meal data entered by the user

[1335] Output: Meal data sent to the server

[1336] Step 18:

[1337] server:

[1338] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any missing nutrients.

[1339] Input: Meal data received from the device

[1340] Output: Evaluation results and areas for improvement

[1341] Step 19:

[1342] server:

[1343] The server identifies areas for improvement based on the evaluation results and generates new improvement suggestions based on the user's preferences and health status. For example, it might suggest a menu with more salad the next day to compensate for a lack of vegetables.

[1344] Input: Evaluation result

[1345] Output: New improvement proposals

[1346] Step 20:

[1347] server:

[1348] Based on the improvement suggestions, the server generates a new menu and provides it to the user so they can try it the next day or the following week.

[1349] Input: Improvement suggestion

[1350] Output: Newly generated menu

[1351] Step 21:

[1352] Terminal:

[1353] The terminal displays improvement suggestions received from the server within the application and provides them to the user.

[1354] Input: Improvement suggestions received from the server

[1355] Output: Visually displayed improvement suggestions

[1356] Step 22:

[1357] User:

[1358] Users review the suggested improvements and incorporate them into their meals the following day or week.

[1359] Input: Visually displayed improvement suggestions

[1360] Output: Meal plan for the next day or next week

[1361] 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 user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1362] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1363] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart glasses 214.

[1364] [Third Embodiment]

[1365] Figure 5 shows an example of the configuration of the data processing system 310 according to the third embodiment.

[1366] As shown in Figure 5, the data processing system 310 includes a data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

[1367] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[1369] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

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

[1371] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[1372] Figure 6 shows an example of the main functions of the data processing device 12 and the headset terminal 314. As shown in Figure 6, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[1373] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[1375] In the headset terminal 314, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[1376] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the headset terminal 314 will be referred to as the "terminal".

[1377] The system of this invention generates and provides menus and recipes based on ingredient information and conditions entered by the user. Furthermore, it supports the user's healthy eating habits by evaluating daily meal data and providing suggestions for improving their diet.

[1378] 1. Input and management of ingredient information

[1379] User

[1380] The user enters ingredient information (e.g., carrots, chicken, spinach) through the application's input form.

[1381] terminal

[1382] The entered ingredient information is sent to the server via an API request.

[1383] server

[1384] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[1385] 2. Selection and management of conditions

[1386] User

[1387] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese), allergens, and calorie restrictions in the application's form.

[1388] terminal

[1389] The selected conditions are sent to the server via an API request.

[1390] server

[1391] The received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[1392] 3. Recipe generation and filtering

[1393] server

[1394] Based on the received ingredient information and conditions, the system searches the database for recipes and generates multiple relevant recipes.

[1395] The generated recipes are filtered according to the user's criteria. For example, recipes can be filtered to include only Japanese cuisine, recipes that do not contain allergens, or recipes that meet calorie restrictions.

[1396] 4. Menu planning and serving

[1397] server

[1398] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week).

[1399] The generated menu and corresponding recipe details are sent to the device as an API response.

[1400] terminal

[1401] The received data is visually displayed within the application and provided to the user.

[1402] User

[1403] Review the provided menu and recipe details, and prepare the dishes as needed.

[1404] 5. Input and evaluation of daily meal data

[1405] User

[1406] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[1407] terminal

[1408] The entered meal data is sent to the server via an API request.

[1409] server

[1410] The system analyzes the received meal data to evaluate calorie intake, nutritional balance, and any nutritional deficiencies.

[1411] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on user preferences and health status.

[1412] 6. Providing suggestions for improvement

[1413] server

[1414] Based on the improvement suggestions, a new menu is generated and provided in a way that users can implement the next day or week.

[1415] terminal

[1416] The application displays improvement suggestions received from the server and provides them to the user.

[1417] User

[1418] We will implement the proposed improvements and enhance the quality of our diet.

[1419] Specific example

[1420] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates the optimal recipe based on this information and presents a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system evaluates the data and makes suggestions for necessary improvements. For example, if a user consumes a lot of "blanched spinach," the system might suggest "carrot tempura" the next day to balance the diet.

[1421] This invention allows users to easily maintain a balanced and healthy diet.

[1422] The following describes the processing flow.

[1423] Step 1: Enter ingredient information

[1424] User

[1425] Enter ingredient information into the application's input form. For example, enter specific ingredient names such as "carrots," "chicken," and "spinach."

[1426] terminal

[1427] The entered ingredient information is sent to the server as an API request.

[1428] Step 2: Selecting the conditions

[1429] User

[1430] You select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens (e.g., peanuts, wheat), and calorie restrictions (e.g., 1200 kcal / day) in the application form.

[1431] terminal

[1432] The selected conditions are sent to the server as an API request.

[1433] Step 3: Preservation and pre-processing of ingredient information and conditions

[1434] server

[1435] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalizing ingredient names, removing duplicates). Additionally, the received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[1436] Step 4: Recipe Generation

[1437] server

[1438] Based on the received ingredient information and conditions, the system searches the database for recipes and generates multiple relevant recipes. For example, if the condition is "Japanese food," only Japanese food recipes will be selected.

[1439] Step 5: Filtering Recipes

[1440] server

[1441] The generated recipes are then further filtered based on specific criteria. For example, you can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[1442] Step 6: Menu Generation

[1443] server

[1444] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[1445] Step 7: Provide menus and recipes

[1446] server

[1447] The generated menu and corresponding recipe details are sent to the device as an API response.

[1448] terminal

[1449] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[1450] User

[1451] Review the provided menu and recipe details, and prepare the dishes as needed.

[1452] Step 8: Enter meal data

[1453] User

[1454] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[1455] terminal

[1456] The entered meal data is sent to the server as an API request.

[1457] Step 9: Analysis and evaluation of dietary data

[1458] server

[1459] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[1460] Step 10: Generating improvement suggestions

[1461] server

[1462] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[1463] Step 11: Providing improvement suggestions

[1464] server

[1465] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[1466] terminal

[1467] The application displays improvement suggestions received from the server and provides them to the user.

[1468] User

[1469] Review the proposed improvements and incorporate them into your meals the following day or week.

[1470] By following the steps outlined above, users can maintain a healthy and balanced diet tailored to their individual needs.

[1471] (Example 1)

[1472] Next, we will describe Example 1. 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."

[1473] Traditional meal planning systems required users to manually create menus based on ingredients and other conditions, a cumbersome and time-consuming process. Furthermore, it was difficult to receive suggestions that considered nutritional balance and health conditions. In addition, there were virtually no suggestions for improving dietary habits based on daily meal data. This made it difficult for users to maintain healthy eating habits.

[1474] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[1475] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for filtering the generated recipes using a generation AI model, means for receiving user-specified conditions, means for filtering recipes generated based on the conditions, means for automatically generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu and visually displaying them on the user terminal, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, and means for suggesting a new menu based on the areas for improvement. As a result, the user can visually confirm a balanced menu that is automatically generated based on the input ingredient information and specified conditions, and can also receive suggestions for improving their healthy eating habits based on their daily meal data.

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

[1477] A "recipe" is information that includes the steps and a list of ingredients for preparing a specific meal.

[1478] A "generative AI model" is a system or algorithm that uses artificial intelligence technology to generate relevant information from data.

[1479] "Conditions" refer to the constraints and requests that the user specifies when generating a recipe (e.g., type of dish, allergens, calorie restrictions).

[1480] "Filtering" is the process of selecting data based on specific criteria.

[1481] A "menu" is a set of meals planned for a specific period of time.

[1482] "Means of visual display" refers to a mechanism for displaying information graphically on a device.

[1483] "Meal data" refers to data in which users input details about their daily meals and the foods they consumed.

[1484] "Evaluating" is the process of analyzing and making judgments based on the input data.

[1485] "Areas for improvement" are elements that need to be changed or adjusted in order to improve one's diet.

[1486] To "propose" means to show methods or means for achieving a specific objective.

[1487] The system of the present invention generates and provides menus and recipes based on ingredient information and conditions entered by the user. Furthermore, it supports the user's healthy eating habits by evaluating daily meal data and providing suggestions for improving their diet. Specific embodiments are described below.

[1488] 1. Input and management of ingredient information

[1489] The user enters ingredient information (e.g., carrots, chicken, spinach) through the application's input form. At this time, they also enter the ingredient name, quantity, and other detailed information.

[1490] The terminal sends the entered ingredient information to the server via an API request. The terminal converts the input data into an appropriate format (e.g., JSON format) and sends it.

[1491] The server stores the received ingredient information in a database. It performs preprocessing such as normalizing ingredient names and removing duplicates so that "ninjin" and "ninjin" are recognized as the same ingredient.

[1492] 2. Selection and management of conditions

[1493] Users select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens, and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[1494] The device sends the selected conditions to the server via an API request. These conditions are treated as session data.

[1495] The server stores the received conditions as session data and uses them for recipe generation and filtering.

[1496] 3. Recipe generation and filtering

[1497] The server searches the database for recipe data and generates multiple candidate recipes based on the entered ingredient information and conditions. This generation process utilizes a generation AI model to produce highly accurate recipes.

[1498] The server filters recipes generated based on the user's criteria. Specifically, it selects recipes that are Japanese cuisine only, do not contain allergens, and are within calorie limits.

[1499] 4. Menu planning and serving

[1500] The server automatically generates meal plans for a specified period (e.g., 3 days, 1 week) based on filtered recipes. It combines menus suitable for each mealtime (breakfast, lunch, dinner).

[1501] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[1502] The device visually displays the received data within the application and provides it to the user. Details on how the user prepares each recipe are also displayed.

[1503] Users can view the displayed menu and recipe details, then prepare the meal. They can adjust the recipe as needed.

[1504] 5. Input and evaluation of daily meal data

[1505] Users input details about the dishes they actually prepared, the calories they consumed, and their impressions into the application.

[1506] The device sends the entered meal data to the server via an API request.

[1507] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any nutrient deficiencies (e.g., vitamins, minerals). If the user is not getting enough vitamin C, this information is recorded.

[1508] 6. Providing suggestions for improvement

[1509] Based on the analysis results, the server generates improvement suggestions that take into account the user's preferences and health condition. For example, if the user is deficient in vitamin C, it might suggest orange juice for breakfast the next day to compensate for the deficiency.

[1510] The server sends improvement suggestions to the terminal as an API response.

[1511] The device displays the received improvement suggestions within the application and provides them to the user.

[1512] Users implement the suggested improvements and enhance the quality of their diet.

[1513] Specific example

[1514] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates an optimal recipe based on this information. A three-day menu is presented, and the user prepares meals according to it. After that, the system analyzes the meal data entered and balances the diet by suggesting "carrot tempura" for the next day.

[1515] Examples of prompts for generative AI models

[1516] If a user enters "carrots," "chicken," and "spinach," and selects the conditions "Japanese cuisine," "no allergies," and "1200 kcal / day calorie restriction," please generate a 3-day meal plan. Also, please include meal suggestions for the following day to ensure balance.

[1517] The flow of the specific processing in Example 1 will be explained using Figure 11.

[1518] Step 1:

[1519] The user enters ingredient information (e.g., carrots, chicken, spinach) into the application's input form.

[1520] Input: Ingredient information entered by the user.

[1521] Output: Ingredient information is temporarily stored within the application.

[1522] Specific operation: When the user enters text into the form and presses the confirmation button, the information proceeds to the next step.

[1523] Step 2:

[1524] The terminal sends the entered ingredient information to the server via an API request.

[1525] Input: Ingredient information entered in Step 1.

[1526] Output: Ingredient information is sent to the server.

[1527] Specific operation: The terminal converts the entered ingredient information into JSON format and sends an HTTP POST request to the API endpoint.

[1528] Step 3:

[1529] The server stores the received ingredient information in a database.

[1530] Input: Ingredient information sent from the device.

[1531] Output: Ingredient information is saved in the database.

[1532] Specific operation: The server saves the received data to the appropriate table in the database using an INSERT statement, and performs normalization and duplicate removal of ingredient names as needed.

[1533] Step 4:

[1534] Users select conditions such as the type of cuisine (Japanese, Western, or Chinese), allergens, and calorie restrictions in an input form.

[1535] Input: User-selected criteria information.

[1536] Output: Condition information is temporarily stored within the application.

[1537] Specific operation: When the user selects conditions using a dropdown menu or checkboxes and presses the confirmation button, the information proceeds to the next step.

[1538] Step 5:

[1539] The device sends the selected conditions to the server via an API request.

[1540] Input: Condition information entered in Step 4.

[1541] Output: Condition information is sent to the server.

[1542] Specific operation: The terminal converts the selected conditions into JSON format and sends an HTTP POST request to the API endpoint.

[1543] Step 6:

[1544] The server stores the received conditions as session data and uses them for subsequent recipe generation and filtering.

[1545] Input: Conditional information sent from the terminal.

[1546] Output: Condition information is saved to the server as session data.

[1547] Specific operation: The server stores the received data in memory as session data and also backs it up in the database.

[1548] Step 7:

[1549] The server searches the database for recipe data and generates multiple candidate recipes based on the entered ingredient information and conditions. This generation process utilizes a generation AI model.

[1550] Input: Recipe data, ingredient information, and condition information from the database.

[1551] Output: Multiple candidate recipes are generated.

[1552] Specific operation: Using a generative AI model, ingredient information and condition information are provided as input, and highly relevant recipes are generated. The generated recipes are temporarily stored in memory.

[1553] Step 8:

[1554] The server filters the recipes generated based on the user's criteria.

[1555] Input: Multiple generated candidate recipes, user criteria information.

[1556] Output: Filtered list of recipes.

[1557] Specific operation: The server uses conditional information to filter candidate recipes, selecting those that are Japanese cuisine only, do not contain allergens, or are within calorie limits.

[1558] Step 9:

[1559] The server automatically generates meal plans for a specified period (e.g., 3 days, 1 week) based on the filtered recipes.

[1560] Input: Filtered list of recipes.

[1561] Output: Automatically generated menu for the specified period.

[1562] Specific operation: The server generates balanced menus by combining menus suitable for each mealtime (breakfast, lunch, and dinner), making it easy for the user to prepare them.

[1563] Step 10:

[1564] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[1565] Input: Automatically generated menu and its details.

[1566] Output: Menu and recipe details sent to the device as an API response.

[1567] Specific operation: The server converts the generated menu and recipe details into JSON format and sends it as an HTTP response to the appropriate API endpoint.

[1568] Step 11:

[1569] The device visually displays the received data within the application.

[1570] Input: Menu and recipe details sent from the server.

[1571] Output: Menu and recipe details displayed visually within the application.

[1572] Specific operation: The terminal parses the received JSON data and visually formats it using HTML and CSS to display it in the user interface.

[1573] Step 12:

[1574] Users review the provided menu and recipe details and then prepare the dishes.

[1575] Input: Displayed menu and recipe details.

[1576] Output: Confirmed menu and prepared dishes.

[1577] Specific actions: The user checks the recipe details displayed on the screen and then actually prepares the dish.

[1578] Step 13:

[1579] Users input details about the dishes they actually prepared, the calories they consumed, and their impressions into the application.

[1580] Input: Details of the meals actually consumed.

[1581] Output: Input meal data.

[1582] Specific operation: The user enters detailed information into the input form and presses the submit button to advance the data to the next step.

[1583] Step 14:

[1584] The device sends the entered meal data to the server via an API request.

[1585] Input: Meal data entered by the user.

[1586] Output: Meal data sent to the server.

[1587] Specific operation: The device converts the meal data into JSON format and sends it to the appropriate API endpoint via an HTTP POST request.

[1588] Step 15:

[1589] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any missing nutrients.

[1590] Input: Meal data entered by the user.

[1591] Output: Evaluation results (calorie intake, nutritional balance, deficient nutrients, etc.).

[1592] Specific operation: The server analyzes the received meal data, calculates the daily nutrient intake, evaluates the nutritional balance, and identifies any deficient nutrients.

[1593] Step 16:

[1594] The server generates improvement suggestions based on the evaluation results, taking into account the user's preferences and health condition.

[1595] Input: Evaluated meal data, user preferences, and health status.

[1596] Output: Improvement suggestions.

[1597] Specific operation: The server suggests the content and menu of meals for the next day, based on evaluation results and the user's past eating history. For example, if the user is deficient in vitamin C, it will suggest orange juice for breakfast.

[1598] Step 17:

[1599] The server sends improvement suggestions to the terminal as an API response.

[1600] Input: Generated improvement suggestions.

[1601] Output: Improvement suggestions sent to the terminal as an API response.

[1602] Specific operation: The server converts the improvement suggestions into JSON format and sends them as an HTTP response to the appropriate API endpoint.

[1603] Step 18:

[1604] The device displays the received improvement suggestions within the application.

[1605] Input: Improvement suggestions sent from the server.

[1606] Output: Improvement suggestions visually displayed within the application.

[1607] Specific operation: The terminal parses the received JSON data and visually formats it using HTML and CSS to display it in the user interface.

[1608] Step 19:

[1609] Users implement the suggested improvements and enhance the quality of their diet.

[1610] Input: Displayed improvement suggestions.

[1611] Output: Improved eating habits as a result of implementing the proposed improvements.

[1612] Specific actions: Users maintain a healthy diet by preparing ingredients according to the displayed improvement suggestions and incorporating them into their next meal.

[1613] (Application Example 1)

[1614] Next, we will explain Application Example 1. In the following explanation, 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."

[1615] In modern society, maintaining a healthy diet amidst a busy lifestyle is a challenging task. Furthermore, creating nutritionally balanced meal plans is time-consuming, highlighting the need for a user-friendly system. Additionally, there is a lack of economic incentives to encourage the purchase of healthy ingredients. Therefore, a system is needed that provides optimal recipes and meal plans based on ingredient information, and also offers cashback to further promote the purchase of healthy ingredients.

[1616] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[1617] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, means for proposing a new menu based on the areas for improvement, and means for providing cashback when healthy ingredients are purchased based on the new menu. As a result, the user can easily maintain a balanced diet while also gaining an incentive to purchase healthy ingredients, thus enjoying both health maintenance and improvement and economic convenience at the same time.

[1618] "Means for receiving ingredient information" refers to the methods or devices used by the system to receive data on the type and quantity of ingredients entered by the user.

[1619] "Means for generating multiple recipes based on received ingredient information" refers to algorithms or programs that suggest multiple recipes for corresponding dishes based on the input ingredient information.

[1620] "Means for presenting a selected recipe from the recipes generated by the recipe generation means" refers to a method or interface for displaying a specific recipe to a user from among multiple generated recipes.

[1621] "Means for receiving user-specified conditions" refers to methods and functions for receiving conditions such as the type of cuisine, allergy information, and calorie restrictions as input from the user.

[1622] "Means for filtering recipes generated based on conditions" refers to algorithms or programs that narrow down the generated recipes by taking into account the conditions specified by the user.

[1623] "Methods for generating menus based on filtered recipes" refers to methods or programs for creating meal plans (menus) for a certain period of time using filtered recipes.

[1624] "Means of providing recipes corresponding to a menu" refers to methods or functions for providing users with specific recipes for dishes based on a created menu.

[1625] "Means for users to input daily meal data" refers to interfaces or devices that allow users to input details of the meals they actually consumed into the system.

[1626] "Methods for evaluating meal data and identifying areas for improvement" refer to algorithms and programs that analyze input meal data and identify areas for improvement from perspectives such as nutritional balance and calorie intake.

[1627] "Methods for suggesting new menus based on areas for improvement" refers to methods or programs for suggesting new meal plans (menus) to users, taking into account identified areas for improvement.

[1628] A "method of providing cashback for purchasing healthy ingredients based on a new menu" refers to a system or service that provides users with an economic incentive (cashback) by purchasing ingredients included in a suggested menu.

[1629] To implement this invention, the following system configuration and program are used.

[1630] System Configuration

[1631] Hardware and software

[1632] Server: Flask (Python), MySQL or PostgreSQL, scikit-learn, TensorFlow

[1633] User device: Smartphone application (Android / iOS)

[1634] System Operation Description

[1635] Input and management of ingredient information

[1636] The user enters ingredient information (e.g., carrots, chicken, spinach) through an input form in a smartphone application. The application sends this information to the server as an API request, and the server stores the received ingredient information in a database. The stored data is preprocessed (e.g., normalization of ingredient names, removal of duplicates).

[1637] Selection and management of conditions

[1638] Users can select the type of dish, allergy information, calorie restrictions, etc., through the application's form. These conditions are sent to the server via API requests and temporarily stored as session data. This data is then used for subsequent recipe generation and filtering.

[1639] Recipe generation and filtering

[1640] The server generates multiple relevant recipes using a generative AI model based on the received ingredient information and conditions. It then filters the recipes based on these conditions, for example, selecting only Japanese cuisine, recipes that do not contain allergens, or recipes within calorie limits.

[1641] Menu planning and serving

[1642] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). The generated meal plans and corresponding recipe details are sent to the device as an API response, allowing the user to visually confirm them within the application.

[1643] Input and evaluation of daily meal data

[1644] Users input details about the dishes they have cooked, the meals they have eaten, the calorie content, and their impressions into the application. The application sends this data to a server, which analyzes the received data to evaluate calorie intake and nutritional balance, and identifies any nutrient deficiencies.

[1645] Providing improvement suggestions

[1646] Based on the evaluation results, the system generates improvement suggestions that take into account the user's preferences and health condition, and proposes new menus. Furthermore, it provides a system where users can receive cashback when purchasing specific healthy ingredients.

[1647] Specific example

[1648] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates an optimal recipe based on this information and presents a three-day meal plan. When the user prepares meals according to this plan and inputs the meal data, the system evaluates the data and makes suggestions for necessary improvements. For example, if a user consumes a lot of "blanched spinach," the system might suggest "carrot tempura" the next day to balance it out. In addition, a system is implemented that offers cashback when users purchase these ingredients, supporting the maintenance of a healthy diet for users.

[1649] Example of a prompt

[1650] Please suggest Japanese recipes using carrots, chicken, and spinach. The calorie limit is 1200 kcal / day. There is no allergy information.

[1651] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[1652] Step 1:

[1653] The user enters ingredient information (e.g., carrots, chicken, spinach) through an input form in the smartphone application. Once the user has finished entering the information, the application formats this ingredient information in JSON format and sends it to the server via an API request. The server saves the received ingredient information to a database and performs pre-processing such as normalizing ingredient names and removing duplicates before saving. In this step, the input is the ingredient information entered by the user, and the output is the saving of the pre-processed ingredient information to the database.

[1654] Step 2:

[1655] The user selects individual conditions such as the type of dish, allergy information, and calorie restrictions through a form in the smartphone application. Once the user has made their selections, the application formats these conditions in JSON format and sends them to the server via an API request. The server temporarily stores the received condition data as session data and uses it for subsequent recipe generation and filtering processes. The input for this step is the condition data selected by the user, and the output is the storage of the session data.

[1656] Step 3:

[1657] The server generates multiple recipes using a generative AI model based on ingredient information and condition data stored in the database. The AI ​​model utilizes the input ingredient information to extract and generate relevant recipes from the corresponding recipe database. The generated recipes are temporarily stored in a cache. The input for this step is ingredient information and condition data, and the output is the generated recipe data.

[1658] Step 4:

[1659] The server filters the generated recipe data based on conditional data. For example, it extracts only recipes that meet the user's criteria, such as Japanese food only, recipes that do not contain allergens, or recipes that are within calorie limits. The filtered recipe data is then stored in the cache again. The input for this step is the generated recipe data and conditional data, and the output is the filtered recipe data.

[1660] Step 5:

[1661] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on the filtered recipes. The generated meal plans and corresponding recipe details are sent to the user's device as an API response. The user can visually view these meal plans and recipe details within the application. The input for this step is filtered recipe data and a specified period, and the output is the generated meal plan data.

[1662] Step 6:

[1663] Users input details such as the dishes they actually prepared, the meals they ate, calories, and their impressions into a smartphone application. The application formats this meal data in JSON format and sends it to the server via an API request. The server analyzes the received meal data, evaluates calorie intake and nutritional balance, and identifies any deficient nutrients. The input for this step is the meal data entered by the user, and the output is the evaluation result data.

[1664] Step 7:

[1665] The server generates improvement suggestions based on the evaluation results, taking into account the user's preferences and health status. It automatically generates a new menu based on the suggested improvements and provides it in a way that the user can implement the next day or week. Furthermore, the application displays a mechanism offering a cashback incentive for purchasing healthy ingredients based on this new menu. The input for this step is the evaluation result data, and the output is the improvement suggestions and cashback information.

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

[1667] This invention is a system that recognizes the user's emotions in addition to the ingredient information and conditions entered by the user, and generates and provides recipes and menus based on those emotions. This system not only improves the quality of the user's diet but also supports a healthier and more satisfying diet by taking into account the user's emotional state.

[1668] 1. Input and management of ingredient information

[1669] User

[1670] The user enters ingredient information into the application's input form. For example, they might enter specific ingredients such as "carrots," "chicken," or "spinach."

[1671] terminal

[1672] The entered ingredient information is sent to the server via an API request.

[1673] server

[1674] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[1675] 2. Selection and management of conditions

[1676] User

[1677] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens (e.g., peanuts, wheat, etc.), and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[1678] terminal

[1679] The selected conditions are sent to the server via an API request.

[1680] server

[1681] The received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[1682] 3. Utilizing the Emotion Engine

[1683] User

[1684] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select options such as "feeling stressed," "feeling happy," or "feeling tired."

[1685] terminal

[1686] The emotional data is sent to the server as an API request.

[1687] server

[1688] Based on the received emotional data, the system analyzes the user's emotional state and generates recipes and menus that are appropriate for that state.

[1689] 4. Recipe generation and filtering

[1690] server

[1691] Based on the received ingredient information, conditions, and emotional data, the system searches the database for recipes and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[1692] server

[1693] The generated recipes are then further filtered based on specific criteria. For example, you can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[1694] 5. Menu creation and provision

[1695] server

[1696] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[1697] server

[1698] The generated menu and corresponding recipe details are sent to the device as an API response.

[1699] terminal

[1700] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[1701] User

[1702] Review the provided menu and recipe details, and prepare the dishes as needed.

[1703] 6. Input and evaluation of daily meal data

[1704] User

[1705] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[1706] terminal

[1707] The entered meal data is sent to the server as an API request.

[1708] server

[1709] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[1710] 7. Generating and providing improvement suggestions

[1711] server

[1712] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[1713] server

[1714] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[1715] terminal

[1716] The application displays improvement suggestions received from the server and provides them to the user.

[1717] User

[1718] Review the proposed improvements and incorporate them into your meals the following day or week.

[1719] Specific example

[1720] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and also inputs their emotional state as "feeling stressed," the server will generate an optimal recipe based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system will evaluate the data and make suggestions for necessary improvements. For example, if the user consumes a lot of "blanched spinach, which has a relaxing effect," the system will balance this by suggesting "glazed carrots, which help reduce stress," on the next day.

[1721] This invention allows users to easily achieve a healthy and balanced diet tailored to their individual circumstances and emotional state.

[1722] The following describes the processing flow.

[1723] Step 1: Enter ingredient information

[1724] User

[1725] Enter ingredient information into the application's input form. For example, enter specific ingredients such as "carrots," "chicken," and "spinach."

[1726] terminal

[1727] The entered ingredient information is sent to the server as an API request.

[1728] Step 2: Selecting the conditions

[1729] User

[1730] You select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens (e.g., peanuts, wheat), and calorie restrictions (e.g., 1200 kcal / day) in the application form.

[1731] terminal

[1732] The selected conditions are sent to the server as an API request.

[1733] Step 3: Preservation and pre-processing of ingredient information and conditions

[1734] server

[1735] The received ingredient information and conditions are saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[1736] Step 4: Entering emotional data

[1737] User

[1738] The application allows users to input or recognize their current emotional state through an emotion input form or emotion recognition function. For example, they can choose from options such as "feeling stressed," "feeling happy," or "feeling tired."

[1739] terminal

[1740] The emotional data is sent to the server as an API request.

[1741] Step 5: Saving and analyzing emotional data

[1742] server

[1743] The received emotional data is stored in a database and analyzed. This allows for the identification of appropriate recipes and menus based on the user's emotional state.

[1744] Step 6: Recipe Generation

[1745] server

[1746] Based on the received ingredient information, conditions, and emotional data, the system searches the database for recipes and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[1747] Step 7: Filtering Recipes

[1748] server

[1749] The generated recipes are then filtered based on specific criteria. For example, recipes can be narrowed down by conditions such as "does not contain allergens" or "is within calorie limits."

[1750] Step 8: Menu Generation

[1751] server

[1752] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[1753] Step 9: Provide menus and recipes

[1754] server

[1755] The generated menu and corresponding recipe details are sent to the device as an API response.

[1756] terminal

[1757] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[1758] User

[1759] Review the provided menu and recipe details, and prepare the dishes as needed.

[1760] Step 10: Enter meal data

[1761] User

[1762] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[1763] terminal

[1764] The entered meal data is sent to the server as an API request.

[1765] Step 11: Analysis and evaluation of dietary data

[1766] server

[1767] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[1768] Step 12: Generating improvement suggestions

[1769] server

[1770] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[1771] Step 13: Providing improvement suggestions

[1772] server

[1773] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[1774] terminal

[1775] The application displays improvement suggestions received from the server and provides them to the user.

[1776] User

[1777] Review the proposed improvements and incorporate them into your meals the following day or week.

[1778] By following the steps outlined above in sequence, users can maintain a healthy and balanced diet tailored to their individual circumstances and emotional state.

[1779] (Example 2)

[1780] Next, we will describe Example 2. 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."

[1781] In modern life, balancing health and diet is becoming increasingly important. However, it is extremely difficult for users to manage daily ingredient selection, recipe planning, and meal planning tailored to their emotional state all at once. In particular, excluding allergens, restricting calories, and simultaneously suggesting menus based on the user's emotions and health condition are challenging with current systems. Furthermore, features that evaluate daily meal data and suggest improvements are generally lacking. An efficient system is needed to solve these problems.

[1782] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[1783] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, means for proposing a new menu based on the areas for improvement, means for inputting or recognizing the user's emotional state, and means for analyzing the emotional state and generating recipes and menus based thereon. As a result, the user can centrally manage ingredient selection, recipe selection, and menu creation tailored to their emotional state in their daily diet, and also receive improvement suggestions according to their health condition.

[1784] "Ingredient information" refers to the specific names of ingredients entered by the user, and indicates the ingredients used in the dish.

[1785] A "recipe generation method" refers to a device or program that has the function of generating a series of cooking procedures and ingredient combinations based on the received ingredient information.

[1786] A "recipe presentation means" refers to a device or program that selects and displays a recipe to be presented to the user from among the recipes generated by the recipe generation means.

[1787] "Conditions" refer to individual requirements specified by the user, such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens, and calorie restrictions.

[1788] A "filtering device" refers to a device or program that selects recipes that match specified conditions from among the generated recipes.

[1789] A "menu generation method" refers to a device or program that automatically assembles a menu for a period specified by the user, based on filtered recipes.

[1790] A "recipe provisioning means" refers to a device or program that provides users with detailed information on the generated menu and its corresponding recipe.

[1791] "Meal data" refers to information about the user's daily meals, including the type of food consumed, calories, and comments.

[1792] "Evaluation means" refers to devices or programs that analyze received meal data and evaluate information such as calorie intake and nutritional balance.

[1793] "Improvement suggestion means" refers to devices or programs that propose new menus based on the areas for improvement identified by the evaluation means.

[1794] "Emotional state" refers to the user's current mental state as input or perceived (for example, feeling stressed, happy, tired, etc.).

[1795] "Emotional analysis means" refers to devices or programs that analyze the emotional state received and generate recipes or menus based on the user's emotions and mood.

[1796] This invention is a system that recognizes the user's emotional state in addition to the ingredient information and conditions entered by the user, and generates and provides recipes and menus based on that. This system not only improves the quality of the user's diet but also supports a healthier and more satisfying diet by taking into account the user's emotional state.

[1797] The implementation of this invention is realized through devices and software that have three main roles: server, terminal, and user.

[1798] server

[1799] The server includes a database (e.g., MySQL, PostgreSQL) for receiving, storing, and pre-processing ingredient information, as well as programs for recipe generation, filtering, sentiment analysis, and menu generation. It is also responsible for evaluating received meal data and generating improvement suggestions. The server also includes an interface for communicating with terminals via API requests.

[1800] terminal

[1801] The terminal provides an input form for the user and sends information such as ingredient information, conditions, emotional state, and meal data to the server as an API request. It also visualizes and provides the user with recipes, menus, and improvement suggestions received from the server. The terminal can be implemented on a variety of devices, including smartphones, tablets, and personal computers.

[1802] User

[1803] Users input ingredient information, conditions, emotional state, and meal data through their device. Furthermore, they utilize the system by creating dishes based on provided recipes and menus, and then inputting data on the meals they actually consumed.

[1804] As a concrete example, if a user uses "carrots," "chicken," and "spinach," sets the conditions of "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and enters "feeling stressed" as their emotional state, the server will generate recipes based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and enters the meal data, the system will analyze the data and, the following day, offer suggestions for improvement, such as "glazed carrots to help reduce stress."

[1805] Examples of prompt statements are as follows:

[1806] "If a user wants to make Japanese food using carrots, chicken, and spinach, what should they do?"

[1807] "Please generate a meal plan suitable for a user who has no allergies, desires a calorie restriction of 1200 kcal / day, and is also experiencing stress."

[1808] This invention allows users to efficiently select ingredients, decide on recipes, and create menus tailored to their emotional state, while also receiving suggestions for improvements based on their health condition. This system contributes to improving the quality of diet and increasing user satisfaction.

[1809] The flow of the specific processing in Example 2 will be explained using Figure 13.

[1810] Step 1:

[1811] The user enters ingredient information. The user enters specific ingredients such as "carrots," "chicken," and "spinach" into the application's input form. The entered ingredient information is sent to the device.

[1812] Step 2:

[1813] The terminal sends ingredient information to the server. The entered ingredient information is sent to the server in the form of an API request. The communication protocol used is HTTP / HTTPS. The input data is often encoded in JSON format.

[1814] Step 3:

[1815] The server stores and preprocesses the ingredient information. The received ingredient information is stored in a database (e.g., MySQL, PostgreSQL). Then, data preprocessing is performed, such as normalizing ingredient names (e.g., unifying "ninjin" to "ninjin") and removing duplicates. The output is formatted ingredient information.

[1816] Step 4:

[1817] The user selects the conditions. The user enters conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens, and calorie restrictions (e.g., 1200 kcal / day) into the application's form. The entered data is saved on the device.

[1818] Step 5:

[1819] The device sends the conditions to the server. The selected conditions are sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the condition data is encoded in JSON format.

[1820] Step 6:

[1821] The server saves the conditions. The received condition data is saved as session data and used for subsequent recipe generation and filtering. The condition data is saved as session data as output.

[1822] Step 7:

[1823] The user inputs emotional data. They use an emotional input form or emotional recognition function to enter their current emotional state (e.g., "feeling stressed"). The emotional data is saved on the device.

[1824] Step 8:

[1825] The device sends emotional data to the server. The emotional data is sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the emotional data is encoded in JSON format.

[1826] Step 9:

[1827] The server analyzes the emotional data. It analyzes the received emotional data to understand the user's emotional state. The analysis is performed using NLP (Natural Language Processing) libraries (e.g., NLTK, spaCy) and emotion analysis models. As a result of the analysis, tags and scores corresponding to the emotional state are obtained.

[1828] Step 10:

[1829] The server generates and filters recipes. It searches the recipe database based on received ingredient information, conditions, and sentiment data, generating multiple relevant recipes. Furthermore, it filters the recipes based on conditions such as "does not contain allergens" and "is within calorie limits." The output is a filtered list of recipes.

[1830] Step 11:

[1831] The server generates a menu and sends it to the terminal. Based on the filtered recipes, it automatically generates a menu for the period specified by the user. The generated menu and recipe details are sent to the terminal as an API response. Menu data is obtained as output.

[1832] Step 12:

[1833] The device displays the menu. The received menu and recipe details are visually displayed within the application. This can be done in a calendar format, and detailed information for each recipe can be viewed with a click. The user reviews this information and prepares the meal.

[1834] Step 13:

[1835] The user inputs meal data. They enter details such as the dishes they actually prepared, the meals they ate, calories, and their impressions into the application. The meal data is saved on the device.

[1836] Step 14:

[1837] The device sends meal data to the server. The entered meal data is sent to the server in the form of an API request. HTTP / HTTPS is used as the communication protocol, and the meal data is encoded in JSON format.

[1838] Step 15:

[1839] The server analyzes and evaluates the meal data. It analyzes the received meal data and evaluates factors such as calorie intake and nutritional balance. It checks whether specific nutrients are deficient or excessive. The evaluation results are provided as output.

[1840] Step 16:

[1841] The server generates improvement suggestions and sends them to the terminal. Based on the evaluation results, it identifies areas for improvement and generates new improvement suggestions based on the user's preferences and health status. The generated improvement suggestions are sent to the terminal as an API response. The output is improvement suggestion data.

[1842] Step 17:

[1843] The device displays improvement suggestions. Received improvement suggestions are displayed within the application. The user reviews them and incorporates them into their meals for the following day or week.

[1844] (Application Example 2)

[1845] Next, we will explain application example 2. In the following explanation, 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."

[1846] Traditional recipe suggestion systems propose recipes based on ingredients and conditions specified by the user. However, this fails to consider the user's emotional state, resulting in meal suggestions that may not be suitable for the user's current mood or health condition. Furthermore, they often lack the functionality to automatically generate menus for multiple days and order ingredients in bulk based on those menus. In addition, they are insufficient in utilizing data on meals actually prepared by the user to provide continuous healthy meal suggestions.

[1847] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for recognizing the user's emotional state, means for optimizing the recipes based on the emotional state, means for automatically generating a menu based on the filtered recipes and presenting menus for each period, means for ordering meals based on the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, and means for proposing a new menu based on the areas for improvement. This makes it possible to propose recipes and menus that take into account the user's emotional state, thereby supporting a healthy and satisfying diet. Furthermore, by providing a function to order ingredients in bulk based on the automatically generated menu, the user's workload can be reduced.

[1848] "Means for receiving ingredient information" refers to an interface that allows the system to receive ingredient information entered by the user and send it to the server.

[1849] "Means for generating multiple recipes" refers to algorithms and processes for searching a database for and generating multiple recipes based on the received ingredient information.

[1850] "A means of presenting a recipe selected from a list of recipes" refers to an interface for presenting the user with the most suitable recipe from among those that have been generated.

[1851] "Means for receiving user-specified conditions" refers to an interface that allows the system to receive conditions entered by the user, such as the type of food, allergy information, and calorie restrictions, and send them to the server.

[1852] "Means for filtering recipes generated based on conditions" refers to algorithms and processes for selecting appropriate recipes based on conditions specified by the user.

[1853] "Means for generating menus" refers to algorithms and processes for automatically generating menus for a specified period by combining selected recipes.

[1854] "Means of providing recipes corresponding to menus" refers to an interface for providing users with generated menus and their corresponding recipes.

[1855] "Means for recognizing the user's emotional state" refers to an input interface and emotion analysis algorithm that the system uses to recognize the user's current emotional state (e.g., stress, happiness, fatigue).

[1856] "Means for optimizing the recipe based on emotional state" refers to an algorithm and process for selecting and suggesting the most suitable recipe to the user, taking into account the recognized emotional state.

[1857] "A means of automatically generating menus and presenting them for each period" refers to an interface that automatically generates menus for a period specified by the user (e.g., 3 days, 1 week) and presents them to the user in a calendar format.

[1858] "A means of ordering meals based on a menu" refers to an interface for ordering specific meals as a food delivery service based on a generated menu.

[1859] "A means of inputting daily meal data" refers to an interface for users to input data into the system, such as the content of meals they actually ate, calories, and their impressions.

[1860] "Methods for evaluating dietary data and identifying areas for improvement" refers to algorithms and processes for analyzing input dietary data, evaluating nutritional balance and calorie intake, and identifying areas for improvement.

[1861] "Methods for suggesting new menus based on areas for improvement" refers to algorithms and processes for suggesting new menus to users based on identified areas for improvement.

[1862] In order to implement this invention, the main components—the server, terminal, and user—must function in coordination. The following describes a specific system embodiment and its processing.

[1863] 1. Input and management of ingredient information

[1864] User:

[1865] The user enters ingredient information into the application's input form. For example, they might enter specific ingredient information such as "carrots," "chicken," and "spinach."

[1866] Terminal:

[1867] The terminal sends the entered ingredient information to the server via an API request.

[1868] server:

[1869] The server stores the received ingredient information in a database and performs preprocessing as needed, such as normalizing ingredient names and removing duplicates.

[1870] 2. Selection and management of conditions

[1871] User:

[1872] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese, etc.), allergens (e.g., peanuts, wheat, etc.), and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[1873] Terminal:

[1874] The device sends the selected conditions to the server via an API request.

[1875] server:

[1876] The server temporarily stores the received conditions as session data and uses them for subsequent recipe generation and filtering.

[1877] 3. Utilizing the Emotion Engine

[1878] User:

[1879] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select options such as "feeling stressed," "feeling happy," or "feeling tired."

[1880] Terminal:

[1881] The device sends emotional data to the server as an API request.

[1882] server:

[1883] The server analyzes the user's emotional state based on the received emotional data and generates recipes and menus that are appropriate for that state.

[1884] 4. Recipe generation and filtering

[1885] server:

[1886] The server searches its database for recipes based on the received ingredient information, conditions, and emotional data, and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[1887] server:

[1888] The server further filters the generated recipes based on specific criteria. For example, it can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[1889] 5. Menu creation and provision

[1890] server:

[1891] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on filtered recipes. For example, it might combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[1892] server:

[1893] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[1894] Terminal:

[1895] The device visually displays the received data within the application and provides it to the user. Specifically, it can display menus in a calendar format and allow users to view detailed information about each recipe with a click.

[1896] User:

[1897] Users review the provided menu and recipe details and prepare the dishes as needed.

[1898] 6. Input and evaluation of daily meal data

[1899] User:

[1900] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[1901] Terminal:

[1902] The terminal sends the entered meal data to the server as an API request.

[1903] server:

[1904] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[1905] 7. Generating and providing improvement suggestions

[1906] server:

[1907] The server identifies areas for improvement based on the evaluation results and generates new improvement suggestions based on the user's preferences and health status. For example, it might suggest a menu with more salad the next day to compensate for a lack of vegetables.

[1908] server:

[1909] Based on the improvement suggestions, the server generates a new menu and provides it to the user so they can try it the next day or the following week.

[1910] Terminal:

[1911] The terminal displays improvement suggestions received from the server within the application and provides them to the user.

[1912] User:

[1913] Users review the suggested improvements and incorporate them into their meals the following day or week.

[1914] Specific example

[1915] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie restriction," and also inputs their emotional state as "feeling stressed," the server will generate an optimal recipe based on this information and present a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system will evaluate the data and provide suggestions for necessary improvements. For example, on a day when the user has consumed a lot of "blanched spinach, which has a relaxing effect," the system may suggest "glazed carrots, which help reduce stress," on the next day to balance things out.

[1916] Example of a prompt:

[1917] "Today's ingredients are carrots and chicken, but I'm feeling stressed. Please suggest a relaxing Japanese recipe under 1200 kcal."

[1918] Thus, the system of this invention is designed to take into account the user's emotional state and support a healthy and satisfying diet. Furthermore, by providing a function to order ingredients in bulk based on automatically generated menus, it reduces the effort required of the user.

[1919] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1920] Step 1:

[1921] User:

[1922] The user enters food information into the application's input form. For example, they enter specific ingredients such as "carrots," "chicken," and "spinach." The entered food information is then sent to the device.

[1923] Input: carrots, chicken, spinach

[1924] Output: Ingredient information sent to the terminal

[1925] Step 2:

[1926] Terminal:

[1927] The terminal sends the entered ingredient information to the server via an API request.

[1928] Input: Ingredient information entered by the user

[1929] Output: Ingredient information sent to the server

[1930] Step 3:

[1931] server:

[1932] The server stores the received ingredient information in a database. Before saving, it performs preprocessing such as normalizing ingredient names and removing duplicates.

[1933] Input: Food ingredient information received from the terminal

[1934] Output: Normalized and deduplication-removed database entries

[1935] Step 4:

[1936] User:

[1937] Users select conditions such as the type of cuisine, allergens, and calorie restrictions through the application's form.

[1938] Input: Japanese food, no allergies, 1200 kcal / day

[1939] Output: Condition information sent to the terminal

[1940] Step 5:

[1941] Terminal:

[1942] The device sends the selected condition information to the server via an API request.

[1943] Input: User-selected condition information

[1944] Output: Condition information sent to the server

[1945] Step 6:

[1946] server:

[1947] The server temporarily stores the received condition information as session data and uses it for subsequent recipe generation and filtering.

[1948] Input: Conditional information received from the device

[1949] Output: Condition information saved as session data

[1950] Step 7:

[1951] User:

[1952] Users input or have their current emotional state recognized through an emotion input form or emotion recognition function within the application. For example, they might select an option such as "I am feeling stressed."

[1953] Input: Feeling stressed

[1954] Output: Emotional data sent to the terminal

[1955] Step 8:

[1956] Terminal:

[1957] The device sends emotional data to the server as an API request.

[1958] Input: User-entered sentiment data

[1959] Output: Sentiment data sent to the server

[1960] Step 9:

[1961] server:

[1962] The server analyzes the user's emotional state based on the received emotional data, and then generates recipes and menus that are appropriate for that state.

[1963] Input: Emotional data received from the device.

[1964] Output: Analyzed emotional state and suggested recipes based on it.

[1965] Step 10:

[1966] server:

[1967] The server searches its database for recipes based on the received ingredient information, conditions, and emotional data, and generates several relevant recipes. For example, if the emotional state is "stressed," it prioritizes recipes containing ingredients with relaxing effects.

[1968] Input: Ingredient information, condition information, emotion data

[1969] Output: Multiple recipes generated

[1970] Step 11:

[1971] server:

[1972] The server further filters the generated recipes based on specific criteria. For example, it can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[1973] Input: Multiple recipes

[1974] Output: Filtered recipes

[1975] Step 12:

[1976] server:

[1977] The server automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week) based on the filtered recipes.

[1978] Input: Filtered recipes

[1979] Output: Automatically generated menus for each period

[1980] Step 13:

[1981] server:

[1982] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[1983] Input: Automatically generated menu

[1984] Output: Menu and recipe details sent to the terminal

[1985] Step 14:

[1986] Terminal:

[1987] The device visually displays the received data within the application and provides it to the user. Specifically, it displays menus in a calendar format and provides an interface for viewing detailed information on each recipe.

[1988] Input: Menu and recipe details received from the server

[1989] Output: Visually displayed menu and recipe details

[1990] Step 15:

[1991] User:

[1992] Users review the provided menu and recipe details and prepare the dishes as needed.

[1993] Input: Visually displayed menu and recipe details

[1994] Output: Cooked food

[1995] Step 16:

[1996] User:

[1997] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[1998] Input: Cooked dishes, meal contents, calories, comments

[1999] Output: Meal data sent to the terminal

[2000] Step 17:

[2001] Terminal:

[2002] The terminal sends the entered meal data to the server as an API request.

[2003] Input: Meal data entered by the user

[2004] Output: Meal data sent to the server

[2005] Step 18:

[2006] server:

[2007] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any missing nutrients.

[2008] Input: Meal data received from the device

[2009] Output: Evaluation results and areas for improvement

[2010] Step 19:

[2011] server:

[2012] The server identifies areas for improvement based on the evaluation results and generates new improvement suggestions based on the user's preferences and health status. For example, it might suggest a menu with more salad the next day to compensate for a lack of vegetables.

[2013] Input: Evaluation result

[2014] Output: New improvement proposals

[2015] Step 20:

[2016] server:

[2017] Based on the improvement suggestions, the server generates a new menu and provides it to the user so they can try it the next day or the following week.

[2018] Input: Improvement suggestion

[2019] Output: Newly generated menu

[2020] Step 21:

[2021] Terminal:

[2022] The terminal displays improvement suggestions received from the server within the application and provides them to the user.

[2023] Input: Improvement suggestions received from the server

[2024] Output: Visually displayed improvement suggestions

[2025] Step 22:

[2026] User:

[2027] Users review the suggested improvements and incorporate them into their meals the following day or week.

[2028] Input: Visually displayed improvement suggestions

[2029] Output: Meal plan for the next day or next week

[2030] The specific processing unit 290 transmits the result of the specific processing to the headset terminal 314. In the headset terminal 314, the control unit 46A causes the speaker 240 and display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[2031] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[2032] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and specific processing may also be performed by the headset terminal 314.

[2033] [Fourth Embodiment]

[2034] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[2035] As shown in Figure 7, the 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.

[2036] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[2037] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

[2038] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

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

[2040] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[2041] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive 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 robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[2042] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[2043] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[2045] In robot 414, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[2046] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[2047] The system of this invention generates and provides menus and recipes based on ingredient information and conditions entered by the user. Furthermore, it supports the user's healthy eating habits by evaluating daily meal data and providing suggestions for improving their diet.

[2048] 1. Input and management of ingredient information

[2049] User

[2050] The user enters ingredient information (e.g., carrots, chicken, spinach) through the application's input form.

[2051] terminal

[2052] The entered ingredient information is sent to the server via an API request.

[2053] server

[2054] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalization of ingredient names, removal of duplicates).

[2055] 2. Selection and management of conditions

[2056] User

[2057] Users select individual conditions such as the type of cuisine (Japanese, Western, Chinese), allergens, and calorie restrictions in the application's form.

[2058] terminal

[2059] The selected conditions are sent to the server via an API request.

[2060] server

[2061] The received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[2062] 3. Recipe generation and filtering

[2063] server

[2064] Based on the received ingredient information and conditions, the system searches the database for recipes and generates multiple relevant recipes.

[2065] The generated recipes are filtered according to the user's criteria. For example, recipes can be filtered to include only Japanese cuisine, recipes that do not contain allergens, or recipes that meet calorie restrictions.

[2066] 4. Menu planning and serving

[2067] server

[2068] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week).

[2069] The generated menu and corresponding recipe details are sent to the device as an API response.

[2070] terminal

[2071] The received data is visually displayed within the application and provided to the user.

[2072] User

[2073] Review the provided menu and recipe details, and prepare the dishes as needed.

[2074] 5. Input and evaluation of daily meal data

[2075] User

[2076] Users input details such as the dishes they actually cooked, the meals they ate, the calories, and their impressions into the application.

[2077] terminal

[2078] The entered meal data is sent to the server via an API request.

[2079] server

[2080] The system analyzes the received meal data to evaluate calorie intake, nutritional balance, and any nutritional deficiencies.

[2081] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on user preferences and health status.

[2082] 6. Providing suggestions for improvement

[2083] server

[2084] Based on the improvement suggestions, a new menu is generated and provided in a way that users can implement the next day or week.

[2085] terminal

[2086] The application displays improvement suggestions received from the server and provides them to the user.

[2087] User

[2088] We will implement the proposed improvements and enhance the quality of our diet.

[2089] Specific example

[2090] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates the optimal recipe based on this information and presents a three-day meal plan. Once the user prepares meals according to this plan and inputs the meal data, the system evaluates the data and makes suggestions for necessary improvements. For example, if a user consumes a lot of "blanched spinach," the system might suggest "carrot tempura" the next day to balance the diet.

[2091] This invention allows users to easily maintain a balanced and healthy diet.

[2092] The following describes the processing flow.

[2093] Step 1: Enter ingredient information

[2094] User

[2095] Enter ingredient information into the application's input form. For example, enter specific ingredient names such as "carrots," "chicken," and "spinach."

[2096] terminal

[2097] The entered ingredient information is sent to the server as an API request.

[2098] Step 2: Selecting the conditions

[2099] User

[2100] You select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens (e.g., peanuts, wheat), and calorie restrictions (e.g., 1200 kcal / day) in the application form.

[2101] terminal

[2102] The selected conditions are sent to the server as an API request.

[2103] Step 3: Preservation and pre-processing of ingredient information and conditions

[2104] server

[2105] The received ingredient information is saved to a database, and preprocessing is performed as needed (e.g., normalizing ingredient names, removing duplicates). Additionally, the received conditions are temporarily stored as session data and used for subsequent recipe generation and filtering.

[2106] Step 4: Recipe Generation

[2107] server

[2108] Based on the received ingredient information and conditions, the system searches the database for recipes and generates multiple relevant recipes. For example, if the condition is "Japanese food," only Japanese food recipes will be selected.

[2109] Step 5: Filtering Recipes

[2110] server

[2111] The generated recipes are then further filtered based on specific criteria. For example, you can narrow down the list by conditions such as "does not contain allergens" or "is within calorie limits."

[2112] Step 6: Menu Generation

[2113] server

[2114] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). For example, it can combine multiple recipes suitable for breakfast, lunch, and dinner to create a meal plan.

[2115] Step 7: Provide menus and recipes

[2116] server

[2117] The generated menu and corresponding recipe details are sent to the device as an API response.

[2118] terminal

[2119] The received data will be visually displayed within the application and provided to the user. Specifically, this will include displaying menus in a calendar format and allowing users to view detailed information for each recipe with a click.

[2120] User

[2121] Review the provided menu and recipe details, and prepare the dishes as needed.

[2122] Step 8: Enter meal data

[2123] User

[2124] You input details such as the dishes you actually made, the meals you ate, the calories, and your impressions into the application.

[2125] terminal

[2126] The entered meal data is sent to the server as an API request.

[2127] Step 9: Analysis and evaluation of dietary data

[2128] server

[2129] The system analyzes received meal data to evaluate calorie intake, nutritional balance, and any nutrient deficiencies. For example, it checks whether a particular nutrient is deficient or in excess.

[2130] Step 10: Generating improvement suggestions

[2131] server

[2132] Based on the evaluation results, areas for improvement are identified, and new improvement suggestions are generated based on the user's preferences and health status. For example, "To compensate for a lack of vegetables, suggest a menu with plenty of salad the next day."

[2133] Step 11: Providing improvement suggestions

[2134] server

[2135] Based on the improvement suggestions, a new menu is generated and provided to the user in a way that allows them to implement it the following day or week.

[2136] terminal

[2137] The application displays improvement suggestions received from the server and provides them to the user.

[2138] User

[2139] Review the proposed improvements and incorporate them into your meals the following day or week.

[2140] By following the steps outlined above, users can maintain a healthy and balanced diet tailored to their individual needs.

[2141] (Example 1)

[2142] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[2143] Traditional meal planning systems required users to manually create menus based on ingredients and other conditions, a cumbersome and time-consuming process. Furthermore, it was difficult to receive suggestions that considered nutritional balance and health conditions. In addition, there were virtually no suggestions for improving dietary habits based on daily meal data. This made it difficult for users to maintain healthy eating habits.

[2144] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[2145] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for filtering the generated recipes using a generation AI model, means for receiving user-specified conditions, means for filtering recipes generated based on the conditions, means for automatically generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu and visually displaying them on the user terminal, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, and means for suggesting a new menu based on the areas for improvement. As a result, the user can visually confirm a balanced menu that is automatically generated based on the input ingredient information and specified conditions, and can also receive suggestions for improving their healthy eating habits based on their daily meal data.

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

[2147] A "recipe" is information that includes the steps and a list of ingredients for preparing a specific meal.

[2148] A "generative AI model" is a system or algorithm that uses artificial intelligence technology to generate relevant information from data.

[2149] "Conditions" refer to the constraints and requests that the user specifies when generating a recipe (e.g., type of dish, allergens, calorie restrictions).

[2150] "Filtering" is the process of selecting data based on specific criteria.

[2151] A "menu" is a set of meals planned for a specific period of time.

[2152] "Means of visual display" refers to a mechanism for displaying information graphically on a device.

[2153] "Meal data" refers to data in which users input details about their daily meals and the foods they consumed.

[2154] "Evaluating" is the process of analyzing and making judgments based on the input data.

[2155] "Areas for improvement" are elements that need to be changed or adjusted in order to improve one's diet.

[2156] To "propose" means to show methods or means for achieving a specific objective.

[2157] The system of the present invention generates and provides menus and recipes based on ingredient information and conditions entered by the user. Furthermore, it supports the user's healthy eating habits by evaluating daily meal data and providing suggestions for improving their diet. Specific embodiments are described below.

[2158] 1. Input and management of ingredient information

[2159] The user enters ingredient information (e.g., carrots, chicken, spinach) through the application's input form. At this time, they also enter the ingredient name, quantity, and other detailed information.

[2160] The terminal sends the entered ingredient information to the server via an API request. The terminal converts the input data into an appropriate format (e.g., JSON format) and sends it.

[2161] The server stores the received ingredient information in a database. It performs preprocessing such as normalizing ingredient names and removing duplicates so that "ninjin" and "ninjin" are recognized as the same ingredient.

[2162] 2. Selection and management of conditions

[2163] Users select conditions such as the type of cuisine (Japanese, Western, Chinese), allergens, and calorie restrictions (e.g., 1200 kcal / day) in the application's form.

[2164] The device sends the selected conditions to the server via an API request. These conditions are treated as session data.

[2165] The server stores the received conditions as session data and uses them for recipe generation and filtering.

[2166] 3. Recipe generation and filtering

[2167] The server searches the database for recipe data and generates multiple candidate recipes based on the entered ingredient information and conditions. This generation process utilizes a generation AI model to produce highly accurate recipes.

[2168] The server filters recipes generated based on the user's criteria. Specifically, it selects recipes that are Japanese cuisine only, do not contain allergens, and are within calorie limits.

[2169] 4. Menu planning and serving

[2170] The server automatically generates meal plans for a specified period (e.g., 3 days, 1 week) based on filtered recipes. It combines menus suitable for each mealtime (breakfast, lunch, dinner).

[2171] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[2172] The device visually displays the received data within the application and provides it to the user. Details on how the user prepares each recipe are also displayed.

[2173] Users can view the displayed menu and recipe details, then prepare the meal. They can adjust the recipe as needed.

[2174] 5. Input and evaluation of daily meal data

[2175] Users input details about the dishes they actually prepared, the calories they consumed, and their impressions into the application.

[2176] The device sends the entered meal data to the server via an API request.

[2177] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any nutrient deficiencies (e.g., vitamins, minerals). If the user is not getting enough vitamin C, this information is recorded.

[2178] 6. Providing suggestions for improvement

[2179] Based on the analysis results, the server generates improvement suggestions that take into account the user's preferences and health condition. For example, if the user is deficient in vitamin C, it might suggest orange juice for breakfast the next day to compensate for the deficiency.

[2180] The server sends improvement suggestions to the terminal as an API response.

[2181] The device displays the received improvement suggestions within the application and provides them to the user.

[2182] Users implement the suggested improvements and enhance the quality of their diet.

[2183] Specific example

[2184] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates an optimal recipe based on this information. A three-day menu is presented, and the user prepares meals according to it. After that, the system analyzes the meal data entered and balances the diet by suggesting "carrot tempura" for the next day.

[2185] Examples of prompts for generative AI models

[2186] If a user enters "carrots," "chicken," and "spinach," and selects the conditions "Japanese cuisine," "no allergies," and "1200 kcal / day calorie restriction," please generate a 3-day meal plan. Also, please include meal suggestions for the following day to ensure balance.

[2187] The flow of the specific processing in Example 1 will be explained using Figure 11.

[2188] Step 1:

[2189] The user enters ingredient information (e.g., carrots, chicken, spinach) into the application's input form.

[2190] Input: Ingredient information entered by the user.

[2191] Output: Ingredient information is temporarily stored within the application.

[2192] Specific operation: When the user enters text into the form and presses the confirmation button, the information proceeds to the next step.

[2193] Step 2:

[2194] The terminal sends the entered ingredient information to the server via an API request.

[2195] Input: Ingredient information entered in Step 1.

[2196] Output: Ingredient information is sent to the server.

[2197] Specific operation: The terminal converts the entered ingredient information into JSON format and sends an HTTP POST request to the API endpoint.

[2198] Step 3:

[2199] The server stores the received ingredient information in a database.

[2200] Input: Ingredient information sent from the device.

[2201] Output: Ingredient information is saved in the database.

[2202] Specific operation: The server saves the received data to the appropriate table in the database using an INSERT statement, and performs normalization and duplicate removal of ingredient names as needed.

[2203] Step 4:

[2204] Users select conditions such as the type of cuisine (Japanese, Western, or Chinese), allergens, and calorie restrictions in an input form.

[2205] Input: User-selected criteria information.

[2206] Output: Condition information is temporarily stored within the application.

[2207] Specific operation: When the user selects conditions using a dropdown menu or checkboxes and presses the confirmation button, the information proceeds to the next step.

[2208] Step 5:

[2209] The device sends the selected conditions to the server via an API request.

[2210] Input: Condition information entered in Step 4.

[2211] Output: Condition information is sent to the server.

[2212] Specific operation: The terminal converts the selected conditions into JSON format and sends an HTTP POST request to the API endpoint.

[2213] Step 6:

[2214] The server stores the received conditions as session data and uses them for subsequent recipe generation and filtering.

[2215] Input: Conditional information sent from the terminal.

[2216] Output: Condition information is saved to the server as session data.

[2217] Specific operation: The server stores the received data in memory as session data and also backs it up in the database.

[2218] Step 7:

[2219] The server searches the database for recipe data and generates multiple candidate recipes based on the entered ingredient information and conditions. This generation process utilizes a generation AI model.

[2220] Input: Recipe data, ingredient information, and condition information from the database.

[2221] Output: Multiple candidate recipes are generated.

[2222] Specific operation: Using a generative AI model, ingredient information and condition information are provided as input, and highly relevant recipes are generated. The generated recipes are temporarily stored in memory.

[2223] Step 8:

[2224] The server filters the recipes generated based on the user's criteria.

[2225] Input: Multiple generated candidate recipes, user criteria information.

[2226] Output: Filtered list of recipes.

[2227] Specific operation: The server uses conditional information to filter candidate recipes, selecting those that are Japanese cuisine only, do not contain allergens, or are within calorie limits.

[2228] Step 9:

[2229] The server automatically generates meal plans for a specified period (e.g., 3 days, 1 week) based on the filtered recipes.

[2230] Input: Filtered list of recipes.

[2231] Output: Automatically generated menu for the specified period.

[2232] Specific operation: The server generates balanced menus by combining menus suitable for each mealtime (breakfast, lunch, and dinner), making it easy for the user to prepare them.

[2233] Step 10:

[2234] The server sends the generated menu and corresponding recipe details to the terminal as an API response.

[2235] Input: Automatically generated menu and its details.

[2236] Output: Menu and recipe details sent to the device as an API response.

[2237] Specific operation: The server converts the generated menu and recipe details into JSON format and sends it as an HTTP response to the appropriate API endpoint.

[2238] Step 11:

[2239] The device visually displays the received data within the application.

[2240] Input: Menu and recipe details sent from the server.

[2241] Output: Menu and recipe details displayed visually within the application.

[2242] Specific operation: The terminal parses the received JSON data and visually formats it using HTML and CSS to display it in the user interface.

[2243] Step 12:

[2244] Users review the provided menu and recipe details and then prepare the dishes.

[2245] Input: Displayed menu and recipe details.

[2246] Output: Confirmed menu and prepared dishes.

[2247] Specific actions: The user checks the recipe details displayed on the screen and then actually prepares the dish.

[2248] Step 13:

[2249] Users input details about the dishes they actually prepared, the calories they consumed, and their impressions into the application.

[2250] Input: Details of the meals actually consumed.

[2251] Output: Input meal data.

[2252] Specific operation: The user enters detailed information into the input form and presses the submit button to advance the data to the next step.

[2253] Step 14:

[2254] The device sends the entered meal data to the server via an API request.

[2255] Input: Meal data entered by the user.

[2256] Output: Meal data sent to the server.

[2257] Specific operation: The device converts the meal data into JSON format and sends it to the appropriate API endpoint via an HTTP POST request.

[2258] Step 15:

[2259] The server analyzes the received meal data and evaluates calorie intake, nutritional balance, and any missing nutrients.

[2260] Input: Meal data entered by the user.

[2261] Output: Evaluation results (calorie intake, nutritional balance, deficient nutrients, etc.).

[2262] Specific operation: The server analyzes the received meal data, calculates the daily nutrient intake, evaluates the nutritional balance, and identifies any deficient nutrients.

[2263] Step 16:

[2264] The server generates improvement suggestions based on the evaluation results, taking into account the user's preferences and health condition.

[2265] Input: Evaluated meal data, user preferences, and health status.

[2266] Output: Improvement suggestions.

[2267] Specific operation: The server suggests the content and menu of meals for the next day, based on evaluation results and the user's past eating history. For example, if the user is deficient in vitamin C, it will suggest orange juice for breakfast.

[2268] Step 17:

[2269] The server sends improvement suggestions to the terminal as an API response.

[2270] Input: Generated improvement suggestions.

[2271] Output: Improvement suggestions sent to the terminal as an API response.

[2272] Specific operation: The server converts the improvement suggestions into JSON format and sends them as an HTTP response to the appropriate API endpoint.

[2273] Step 18:

[2274] The device displays the received improvement suggestions within the application.

[2275] Input: Improvement suggestions sent from the server.

[2276] Output: Improvement suggestions visually displayed within the application.

[2277] Specific operation: The terminal parses the received JSON data and visually formats it using HTML and CSS to display it in the user interface.

[2278] Step 19:

[2279] Users implement the suggested improvements and enhance the quality of their diet.

[2280] Input: Displayed improvement suggestions.

[2281] Output: Improved eating habits as a result of implementing the proposed improvements.

[2282] Specific actions: Users maintain a healthy diet by preparing ingredients according to the displayed improvement suggestions and incorporating them into their next meal.

[2283] (Application Example 1)

[2284] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[2285] In modern society, maintaining a healthy diet amidst a busy lifestyle is a challenging task. Furthermore, creating nutritionally balanced meal plans is time-consuming, highlighting the need for a user-friendly system. Additionally, there is a lack of economic incentives to encourage the purchase of healthy ingredients. Therefore, a system is needed that provides optimal recipes and meal plans based on ingredient information, and also offers cashback to further promote the purchase of healthy ingredients.

[2286] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[2287] In this invention, the server includes means for receiving ingredient information, means for generating multiple recipes based on the received ingredient information, means for presenting a recipe selected from the recipes generated by the recipe generation means, means for receiving conditions specified by the user, means for filtering recipes generated based on the conditions, means for generating a menu based on the filtered recipes, means for providing recipes corresponding to the menu, means for the user to input daily meal data, means for evaluating the meal data and identifying areas for improvement, means for proposing a new menu based on the areas for improvement, and means for providing cashback when healthy ingredients are purchased based on the new menu. As a result, the user can easily maintain a balanced diet while also gaining an incentive to purchase healthy ingredients, thus enjoying both health maintenance and improvement and economic convenience at the same time.

[2288] "Means for receiving ingredient information" refers to the methods or devices used by the system to receive data on the type and quantity of ingredients entered by the user.

[2289] "Means for generating multiple recipes based on received ingredient information" refers to algorithms or programs that suggest multiple recipes for corresponding dishes based on the input ingredient information.

[2290] "Means for presenting a selected recipe from the recipes generated by the recipe generation means" refers to a method or interface for displaying a specific recipe to a user from among multiple generated recipes.

[2291] "Means for receiving user-specified conditions" refers to methods and functions for receiving conditions such as the type of cuisine, allergy information, and calorie restrictions as input from the user.

[2292] "Means for filtering recipes generated based on conditions" refers to algorithms or programs that narrow down the generated recipes by taking into account the conditions specified by the user.

[2293] "Methods for generating menus based on filtered recipes" refers to methods or programs for creating meal plans (menus) for a certain period of time using filtered recipes.

[2294] "Means of providing recipes corresponding to a menu" refers to methods or functions for providing users with specific recipes for dishes based on a created menu.

[2295] "Means for users to input daily meal data" refers to interfaces or devices that allow users to input details of the meals they actually consumed into the system.

[2296] "Methods for evaluating meal data and identifying areas for improvement" refer to algorithms and programs that analyze input meal data and identify areas for improvement from perspectives such as nutritional balance and calorie intake.

[2297] "Methods for suggesting new menus based on areas for improvement" refers to methods or programs for suggesting new meal plans (menus) to users, taking into account identified areas for improvement.

[2298] A "method of providing cashback for purchasing healthy ingredients based on a new menu" refers to a system or service that provides users with an economic incentive (cashback) by purchasing ingredients included in a suggested menu.

[2299] To implement this invention, the following system configuration and program are used.

[2300] System Configuration

[2301] Hardware and software

[2302] Server: Flask (Python), MySQL or PostgreSQL, scikit-learn, TensorFlow

[2303] User device: Smartphone application (Android / iOS)

[2304] System Operation Description

[2305] Input and management of ingredient information

[2306] The user enters ingredient information (e.g., carrots, chicken, spinach) through an input form in a smartphone application. The application sends this information to the server as an API request, and the server stores the received ingredient information in a database. The stored data is preprocessed (e.g., normalization of ingredient names, removal of duplicates).

[2307] Selection and management of conditions

[2308] Users can select the type of dish, allergy information, calorie restrictions, etc., through the application's form. These conditions are sent to the server via API requests and temporarily stored as session data. This data is then used for subsequent recipe generation and filtering.

[2309] Recipe generation and filtering

[2310] The server generates multiple relevant recipes using a generative AI model based on the received ingredient information and conditions. It then filters the recipes based on these conditions, for example, selecting only Japanese cuisine, recipes that do not contain allergens, or recipes within calorie limits.

[2311] Menu planning and serving

[2312] Based on filtered recipes, the system automatically generates meal plans for a period specified by the user (e.g., 3 days, 1 week). The generated meal plans and corresponding recipe details are sent to the device as an API response, allowing the user to visually confirm them within the application.

[2313] Input and evaluation of daily meal data

[2314] Users input details about the dishes they have cooked, the meals they have eaten, the calorie content, and their impressions into the application. The application sends this data to a server, which analyzes the received data to evaluate calorie intake and nutritional balance, and identifies any nutrient deficiencies.

[2315] Providing improvement suggestions

[2316] Based on the evaluation results, the system generates improvement suggestions that take into account the user's preferences and health condition, and proposes new menus. Furthermore, it provides a system where users can receive cashback when purchasing specific healthy ingredients.

[2317] Specific example

[2318] For example, if a user inputs ingredients such as "carrots," "chicken," and "spinach," and selects conditions such as "Japanese food," "no allergies," and "1200 kcal / day calorie limit," the server generates an optimal recipe based on this information and presents a three-day meal plan. When the user prepares meals according to this plan and inputs the meal data, the system evaluates the data and makes suggesti...

Claims

1. Means of receiving information about ingredients, A means for generating multiple recipes based on received ingredient information, A means for presenting a recipe selected from the recipes generated by the aforementioned recipe generation means, A means of receiving conditions specified by the user, A means for filtering recipes generated based on the above conditions, A means for generating a menu based on the filtered recipes, Means for providing recipes corresponding to the aforementioned menu, A means for users to input their daily meal data, A means for evaluating the aforementioned dietary data and identifying areas for improvement, A means of proposing a new menu based on the aforementioned improvements, A system that includes this.

2. The system according to claim 1, characterized in that the aforementioned conditions include the type of dish, allergens, and calorie restrictions.

3. The system according to claim 1, characterized in that the recipe providing means includes means for displaying the generated menu and the corresponding recipe on a user terminal.

Images