System

Abstract

A system is provided.SOLUTION: Means for inputting preferences, dietary restrictions, allergy information, and dietary history of a user, means for transmitting the input information to a server, means for storing the received user information in a database in the server, means for analyzing the user information by a natural language processing module in the server, and means for executing a recipe generation algorithm based on an analysis result, A system comprising: means for generating an optimum recipe for a user; means for transmitting the generated recipe to a terminal of the user; means for displaying the transmitted recipe on the terminal of the user; means for transmitting feedback from the user to a server; means for storing and analyzing the received feedback in a database in the server; and means for optimizing a recipe generation algorithm based on an analysis result.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] In modern society, there is an increasing number of dual-income couples and single people in their 20s to 40s who lack cooking ideas and time. This target demographic tends to fall into a rut when it comes to cooking and rely on eating out and delivery. Furthermore, it is difficult to cook dishes that suit individual tastes and dietary restrictions because recipes tailored to individual tastes and restrictions are hard to find. Conventional recipe provision methods make it difficult to consistently provide these users with fully customized recipes. The purpose of this invention is to solve these problems and provide each user with the optimal diet. [Means for solving the problem]

[0005] The present invention solves the above problems by using the following means.

[0006] The system includes: a means for inputting a user's preferences, dietary restrictions, allergy information, and dietary history; a means for transmitting the input information to a server; a means for storing the received user information in a database in the server; a means for analyzing the user information using a natural language processing module in the server; a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user; a means for transmitting the generated recipe to the user's device; a means for displaying the transmitted recipe on the user's device; a means for transmitting user feedback to the server; a means for storing and analyzing the received feedback in a database in the server; and a means for optimizing the recipe generation algorithm based on the analysis results. This system allows users to continuously receive recipes tailored to their preferences and dietary restrictions, enabling them to achieve a diet optimized for each individual user. Furthermore, by providing a means for generating recipes that take into account the difficulty, time required, and ease of obtaining ingredients, the system can provide recipes that are easy for even beginners to follow. Furthermore, by providing a means for analyzing user feedback using a machine learning algorithm and reflecting it in the next recipe generation, the accuracy of the recipes can be improved.

[0007] "User" refers to an individual who uses the system to create recipes and manage meals.

[0008] "Preferences" refers to information indicating the types of ingredients and dishes that a user prefers.

[0009] "Dietary restrictions" refers to information indicating that a user should avoid certain ingredients or dishes for health, religious, or other reasons.

[0010] "Allergy information" refers to information about ingredients that cause a user to have an allergic reaction.

[0011] "Diet history" refers to information about the dishes a user has made in the past and their ratings.

[0012] "Terminal" refers to a device (smartphone, tablet, PC, etc.) that a user uses to access the system and input information and display recipes.

[0013] "Server" refers to a central computer system for receiving and analyzing user information and generating recipes.

[0014] "Database" refers to a storage device for storing user profile information and feedback.

[0015] A "natural language processing module" refers to the algorithms and software that analyze user input and understand its meaning.

[0016] A "recipe generation algorithm" refers to a computational method or process for constructing an optimal recipe based on user information.

[0017] "Natural language generation AI" refers to artificial intelligence technology that generates recipe details in natural language based on analyzed information.

[0018] "Feedback" refers to the ratings and comments users provide after using a recipe.

[0019] "Machine learning algorithms" refer to learning models and methods that use collected feedback information to improve recipe generation in future recipes.

[0020] "Recipe difficulty" refers to the technical difficulty of preparing the recipe.

[0021] "Time required" refers to the time required to complete the recipe.

[0022] "Ingredient Acquisition Difficulty" refers to information about how easily the ingredients needed for a recipe can be obtained. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0031] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0044] The present invention is a system that provides original recipes that take into account the user's preferences, dietary restrictions, allergy information, and dietary history. This system mainly involves a process in which the user inputs information through a terminal, the server generates recipes based on that information, and then receives feedback and makes improvements.

[0045] System Overview

[0046] The system consists of a device used by the user and a server that supports it. Users enter profile information such as preferences, dietary restrictions, allergies, and dietary history through their own device. This information is sent to the server, which stores it in a database. Here, a natural language processing module analyzes the user information and runs a recipe generation algorithm to generate the optimal recipe for the user.

[0047] Program processing

[0048] User: The user first launches the application and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, they can enter chicken as their favorite food, onions as their least favorite food, nuts as their allergic food, and request a low-calorie diet.

[0049] Terminal: The entered information is sent from the user's terminal to the server. The terminal sends this information in the appropriate format so that the server can receive it.

[0050] Server: The server stores the received information in a database, which stores each user's profile information. A natural language processing module then analyzes the stored information to identify the user's preferences and restrictions.

[0051] Server: The recipe generation algorithm is executed based on the analysis results. The algorithm searches the database for relevant recipes and customizes them to suit the user's preferences and restrictions. For example, a "low-calorie recipe using chicken and tomatoes" may be generated. The algorithm also takes into account the difficulty of the recipe, the time required, and the difficulty of obtaining ingredients, so recipes that are easy for beginners to follow are provided.

[0052] Server: The generated recipe is described in detail by natural language generation AI and sent to the user's device.

[0053] Device: The generated recipe is displayed on the user's device. The user checks the recipe, prepares the necessary ingredients, and starts cooking. The recipe includes cooking instructions, a list of ingredients, cooking time, and important notes.

[0054] User: After cooking is complete, the user can provide feedback on the recipe. For example, they can comment, "It was delicious, but I wish it had a few more spices."

[0055] Terminal: The feedback information is sent back to the server, which stores it in a database.

[0056] Server: The received feedback is analyzed using a machine learning algorithm. The recipe generation algorithm is adjusted based on the feedback and reflected in future recipe generation. This allows the system to provide recipes that are more tailored to the user's preferences.

[0057] In this way, the present invention is a system that can generate and provide optimal original recipes taking into account the user's preferences, dietary restrictions, and allergy information. Furthermore, it is possible to continuously improve the recipe generation algorithm based on user feedback, realizing an optimal diet for each individual user.

[0058] The processing flow will be explained below.

[0059] Step 1:

[0060] User: Launches the application and logs in. Enters profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite foods are chicken and tomatoes, my least favorite foods are onions, I'm allergic to nuts, and I prefer a low-calorie diet."

[0061] Step 2:

[0062] Device: The entered profile information is sent to the server using a common data format such as JSON.

[0063] Step 3:

[0064] Server: Stores the received profile information in a database. A unique ID is assigned to each user, and the profile information is categorized and organized.

[0065] Step 4:

[0066] Server: Analyzes profile information using a natural language processing module, identifies user preferences, allergies, and dietary restrictions from the information, and extracts analysis results.

[0067] Step 5:

[0068] Server: Runs the recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. This takes into account the difficulty of the recipe, the time required, and the ease of obtaining ingredients. For example, it selects a "low-calorie recipe with chicken and tomatoes."

[0069] Step 6:

[0070] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[0071] Step 7:

[0072] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[0073] Step 8:

[0074] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[0075] Step 9:

[0076] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[0077] Step 10:

[0078] Terminal: After cooking, a rating form is displayed to the user, providing a star rating (1 to 5 stars) and a comment input field.

[0079] Step 11:

[0080] User: Enter feedback about the cooking. For example, enter a comment like "4 stars, it was delicious but I'd like it to be a little spiced up."

[0081] Step 12:

[0082] Terminal: Sends the entered feedback to the server. Feedback data is also sent in JSON format.

[0083] Step 13:

[0084] Server: Stores the received feedback in a database and analyzes it. It identifies common comments and evaluation points from the feedback.

[0085] Step 14:

[0086] Server: The machine learning algorithm optimizes the recipe generation algorithm based on the feedback information. The feedback is used as learning data to be reflected in future recipe generation.

[0087] In this way, the present invention provides recipes that are customized based on a user's preferences, dietary restrictions, and allergy information, and can continuously improve their accuracy based on user feedback.

[0088] Example 1

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

[0090] Conventional recipe provision systems have had the problem of being unable to provide original recipes that fully take into account the user's preferences, dietary restrictions, allergy information, and dietary history. Furthermore, there were few systems that could efficiently analyze user feedback and reflect it in the next recipe generation. This made it difficult to provide recipes that were suited to each individual user, and there was a need to improve user satisfaction.

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

[0092] In this invention, the server includes a means for storing received user information in a database, a means for analyzing the user information using a natural language processing module, a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user, and a means for describing the generated recipe in detail using a natural language generation model and transmitting the description to the user's terminal. This makes it possible to provide optimal recipes that take into account the user's individual preferences and dietary restrictions. In addition, user feedback can be analyzed using a machine learning algorithm and reflected in the next recipe generation, enabling continuous system optimization.

[0093] "User" refers to a person who uses a terminal to input information such as preferences, dietary restrictions, allergy information, and dietary history, and receives the optimal recipe from the system.

[0094] "Preferences" is information that indicates the specific ingredients or types of dishes that a user likes.

[0095] "Dietary Restrictions" refers to information about specific ingredients or foodstuffs that a user should avoid consuming.

[0096] "Allergy information" is information about specific ingredients to which a user may have an allergic reaction.

[0097] "Dietary history" is information about a record of meals the user has taken in the past and their evaluations.

[0098] "Terminal" refers to the hardware device through which a user inputs information and checks recipes, such as a smartphone, tablet, or PC.

[0099] A "server" is a computer system that receives information sent by users, stores it in a database, and performs analysis and recipe generation.

[0100] A "database" is a digital storage system for storing user information, generated recipes, feedback information, and the like.

[0101] A "natural language processing module" is a software module for analyzing received user information and understanding text data.

[0102] A "recipe generation algorithm" is a series of calculations used to generate optimal recipes based on a user's preferences, dietary restrictions, etc.

[0103] A "natural language generation model" is an AI technology that describes the generated recipe in detail and provides it to the user in natural language.

[0104] "Feedback" refers to comments that users can send to the system, such as their thoughts, ratings, and suggestions for improvement regarding the provided recipe.

[0105] A "machine learning algorithm" is a learning method that analyzes user feedback and reflects it in the next recipe generation.

[0106] The present invention is a system that provides original recipes that take into account the user's preferences, dietary restrictions, allergy information, and dietary history. This system involves a process in which the user inputs information through a terminal, the server generates recipes based on that information, and the system receives feedback and makes improvements.

[0107] Hardware and software used

[0108] Device: The device used by the user, such as a smartphone, tablet, or PC (e.g., iOS, Android, Windows, macOS).

[0109] Server: Cloud server (e.g. AWS, Google Cloud, Microsoft Azure).

[0110] software:

[0111] Natural language processing modules (e.g. spaCy, NLTK).

[0112] Recipe generation algorithms (custom algorithms, machine learning models).

[0113] Database (e.g. MySQL, PostgreSQL).

[0114] Natural language generation AI (e.g. GPT-3, ChatGPT).

[0115] Program Processing Details

[0116] User: First, the user launches a dedicated application on their device and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, the user might fill in the input form with "Favorite food: chicken," "Disliked food: onion," "Allergy: nuts," "Desired: low calorie," etc.

[0117] Terminal: The terminal encrypts the information entered by the user using HTTPS and sends it to the server via a REST API. The terminal converts the information into JSON format and sends a request to the appropriate API endpoint.

[0118] Server: The server analyzes the received information and stores it in a database. The database stores each user's profile information. The server then analyzes the user information using a natural language processing module (e.g., spaCy), tokenizing the text data and identifying keywords such as "favorite ingredients" or "allergies." It then identifies the user's preferences and restrictions and prepares the analysis results.

[0119] Server: Runs a recipe generation algorithm based on the analysis results. This algorithm searches the database for suitable recipes. For example, it prioritizes recipes that use "chicken and tomato" or low-calorie recipes. The generated recipe is then written in detailed text using natural language generation AI (e.g., GPT-3). The generation AI generates the recipe name "Low-calorie chicken and tomato salad," along with cooking instructions, ingredient list, required time, and precautions.

[0120] Server: The generated recipe is sent to the user's device via the REST API in JSON format.

[0121] Device: The user's device receives the data from the server and displays the recipe on the app's UI. The user can check this information, prepare the necessary ingredients, and start cooking.

[0122] User: After cooking is complete, the user can enter feedback about the recipe through the application. For example, they can comment in the text box, "It was delicious, but I would like it to be a little more spiced."

[0123] Terminal: The feedback information entered by the user is again sent from the terminal to the server. This process is also encrypted using HTTPS and sent via the REST API, just like the information sending step.

[0124] Server: The received feedback is analyzed by a machine learning algorithm. The server analyzes the feedback using a natural language processing module and classifies the feedback content by element. For example, it extracts positive comments such as "delicious" and "I'd like to add some spices" as well as requests for improvement. The recipe generation algorithm is adjusted based on the analysis results. The feedback content is added as a new data point to the algorithm's training data, and the model is retrained, so that it is reflected in future recipe generation.

[0125] Examples of concrete examples and prompts

[0126] Examples:

[0127] User: "I like chicken, hate onions, and I'm allergic to nuts. I'd also like to eat a low-calorie diet."

[0128] Recipe generated from the server: "Low-calorie salad with chicken and tomatoes. Cooking instructions: 1. Boil the chicken. 2. Chop the tomatoes. 3. Mix the chicken and tomatoes and toss with olive oil."

[0129] Example prompt for generative AI model:

[0130] User Information:

[0131] Favorite food: Chicken

[0132] Disliked food: Onions

[0133] Allergies: Nuts

[0134] Desired: Low calorie

[0135] Use this information to generate low-calorie recipes tailored to your users.

[0136] In this way, the present invention creates a system that can generate and provide optimal original recipes taking into account the user's preferences, dietary restrictions, and allergy information. Furthermore, it is possible to continuously improve the recipe generation algorithm based on user feedback, realizing an optimized diet for each individual user.

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

[0138] Step 1:

[0139] Information input step

[0140] User: First, the user launches a dedicated application on their device and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, the user might fill in the input form with "Favorite food: chicken," "Disliked food: onion," "Allergy: nuts," "Want: low calories," etc. This information becomes data used to communicate the user's individual preferences and restrictions to the system.

[0141] Step 2:

[0142] Information transmission steps

[0143] Terminal: The terminal encrypts the information entered by the user using HTTPS and sends it to the server via the REST API. The terminal converts the information into JSON format and sends a request to the appropriate API endpoint. The input data (preferences, allergy information, dietary restrictions, dietary history) is encrypted and sent to the server.

[0144] Step 3:

[0145] Information storage step

[0146] Server: The server parses the received information and stores it in a database. This information includes the user's preferences, allergy information, dietary restrictions, and past dietary history. The database stores profile information for each user. The received input data is parsed and inserted into the "users" table using a database manipulation library (e.g., SQLAlchemy).

[0147] Step 4:

[0148] Information Analysis Step

[0149] Server: The server uses a natural language processing module (e.g., spaCy) to analyze user information. For example, it tokenizes text data and identifies keywords such as "favorite ingredients" and "allergies." As a result, the user's preferences and restrictions become clear. The input data is user information (preferences, allergy information, dietary restrictions), and this data is analyzed to output results such as "favorite ingredients: chicken" and "allergies: nuts."

[0150] Step 5:

[0151] Recipe Generation Steps

[0152] Server: Runs a recipe generation algorithm based on the analysis results. This algorithm searches the database for suitable recipes and customizes them to fit the user's preferences and restrictions. For example, it may prioritize recipes using "chicken and tomatoes" or low-calorie recipes. The analysis results are provided as input data, and a customized recipe is output based on them.

[0153] Step 6:

[0154] Recipe Description Steps

[0155] Server: The generated recipe is described in detail as text using natural language generation AI (e.g., GPT-3). The generation AI creates information such as the recipe name "Low-calorie chicken and tomato salad," cooking instructions, ingredient list, required time, and precautions. The input data is the analysis results and the generated recipe, and a detailed recipe is output based on this.

[0156] Step 7:

[0157] Recipe Send and View Steps

[0158] Server: The generated recipe is sent to the user's device. This is also sent in JSON format via the REST API. The generated recipe data is entered and converted into the format to be sent.

[0159] Device: The user's device receives the data from the server and displays it on the app's UI. The user can check the recipe details and start cooking through this UI. The received JSON data is converted into a format that is displayed in the UI.

[0160] Step 8:

[0161] Feedback Input Step

[0162] User: After cooking is complete, the user enters feedback about the recipe through the application. For example, they might comment in a text box, "It was delicious, but I'd like it to have a bit more spice." This feedback information becomes data to improve the recipe generation for future recipes.

[0163] Step 9:

[0164] Feedback submission step

[0165] Terminal: The feedback information entered by the user is again sent from the terminal to the server. This process, like the information sending step, is encrypted using HTTPS and sent via the REST API. The input data is the user's feedback content, which is encrypted and sent to the server.

[0166] Step 10:

[0167] Feedback Analysis Step

[0168] Server: The received feedback is analyzed using a machine learning algorithm. The server analyzes the feedback using a natural language processing module and classifies the feedback content by element. For example, it extracts positive comments such as "delicious" and "I'd like to add some spice" as well as requests for improvement. The feedback data is input and the content is output by category.

[0169] Step 11:

[0170] Algorithm Adjustment Steps

[0171] Server: Adjusts the recipe generation algorithm based on the analysis results. The feedback content is added as a new data point to the algorithm's training data, and the model is retrained. This is reflected in future recipe generation. The feedback analysis results are input, and an optimized algorithm is output.

[0172] Step 12:

[0173] Optimized recipe provision steps

[0174] Server: Based on user feedback, the algorithm is adjusted so that future recipes are more tailored to the individual user. This allows the user to receive recipes that are increasingly tailored to them. Using the optimized algorithm, new recipes are generated and output.

[0175] (Application example 1)

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

[0177] Many modern food delivery services offer a standard menu without adequately considering individual requirements such as user preferences, dietary restrictions, and allergy information. This makes it difficult for users to choose the right dish, and they may suggest dishes that do not accommodate allergies or dietary restrictions. This results in lower user satisfaction and a decrease in the frequency of use of food delivery services. Furthermore, the lack of a mechanism for incorporating feedback after an order to improve suggestions for the next order slows down the improvement of the user experience.

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

[0179] In this invention, the server includes means for inputting a user's preferences, dietary restrictions, allergy information, and dietary history, means for transmitting the input information to the server, and means for storing the received user information in a database. This enables the generation of optimal recipes that take into account the user's individual requirements. The server further includes means for analyzing the user information using a natural language processing module, means for executing a recipe generation algorithm based on the analysis results to generate an optimal recipe for the user, means for transmitting the generated recipe to the user's terminal, means for displaying the transmitted recipe on the user's terminal, and means for transmitting feedback from the user to the server. The server also includes means for storing and analyzing the received feedback in a database, means for optimizing the recipe generation algorithm based on the analysis results, means for searching for and suggesting suppliers that provide suggested dishes based on the generated recipe, and means for directly ordering from the suggested suppliers. This allows users to easily order dishes that suit their preferences and dietary restrictions, and the next suggestions are further optimized based on the feedback, significantly improving the user experience.

[0180] "User preferences" refer to the characteristics of ingredients and dishes that the user likes to eat.

[0181] "Dietary restrictions" are restrictions on ingredients or nutrients that a user wants to avoid for reasons such as health or dieting.

[0182] "Allergy information" is information about ingredients that may cause an allergic reaction to the user.

[0183] "Dietary history" is a record of meals that a user has eaten in the past.

[0184] A "server" is a computer system that receives, stores, and analyzes user input information, and generates and provides recipes.

[0185] A "natural language processing module" is a technology for analyzing information entered by a user and understanding its meaning.

[0186] A "recipe generation algorithm" is a method for automatically generating optimal recipes based on a user's preferences and restrictions.

[0187] "Feedback" refers to the user's opinions and impressions about the recipe provided.

[0188] A "supplier" is a restaurant or delivery service provider that provides food to users.

[0189] A "terminal" is a device (e.g., smartphone, tablet) that a user uses to enter information and receive recipe suggestions.

[0190] A "database" is a system for storing and managing user information and feedback within a server.

[0191] "Machine learning algorithms" are technologies that analyze user feedback and improve future recipe suggestions.

[0192] This invention is a system that provides original recipes taking into account a user's preferences, dietary restrictions, allergy information, and dietary history, and further improves the recipes based on feedback. The system is primarily composed of a user terminal and a server. Specific embodiments of this system are described below.

[0193] First, the user inputs their preferences, allergy information, dietary restrictions, past dietary history, etc. into the terminal. For example, if a user likes chicken, dislikes onions, is allergic to nuts, and wishes to eat a low-calorie diet, they input this information into the terminal. The terminal then sends this information in an appropriate format to the server.

[0194] The server stores the received information in a database. The database stores profile information for each user. Next, the server uses a natural language processing module (e.g., SpaCy) to analyze the user information. This analysis identifies the user's preferences and restrictions. For example, "chicken" and "low calorie" are analyzed.

[0195] Based on the analysis results, the server runs a recipe generation algorithm (generative AI model) to generate the optimal recipe for the user. The generated recipe is then described in detail using natural language generation AI and sent to the device. The generated recipe is then displayed on the user's device. The recipe includes cooking instructions, a list of ingredients, required time, and important notes.

[0196] Furthermore, the server searches for and suggests suppliers (restaurants and delivery services) that offer the proposed dishes based on the generated recipe. The user can then place an order directly from the provided supplier. For example, a restaurant that offers a "low-calorie recipe using chicken and tomatoes" is suggested, and the user can then place an order.

[0197] After cooking is complete, the user can enter feedback on the recipe, such as "It was delicious, but I wish it had a bit more spice." This feedback information is sent back to the server, which stores it in a database.

[0198] The received feedback is analyzed by a machine learning algorithm (e.g., TensorFlow) on the server. The recipe generation algorithm is adjusted based on the feedback and reflected in future recipe generation. This allows the system to provide recipes that are more tailored to the user's preferences.

[0199] Hardware / Software used

[0200] Hardware: Smartphones, servers

[0201] Software: Android / iOS applications, Python, Django (web framework), natural language processing modules (e.g., SpaCy), machine learning models (e.g., TensorFlow)

[0202] Specific examples

[0203] User "Yamada Taro" uses the system to search for new recipes. He enters the following information into his profile:

[0204] Favorite ingredients: chicken, tomatoes

[0205] Disliked food: Onions

[0206] Allergies: Nuts

[0207] Dietary restrictions: low calorie

[0208] Generative AI model prompt example

[0209] Here are some example prompts for a generative AI model:

[0210] Based on the profile of user "Yamada Taro", generate low-calorie recipes that meet the following criteria:

[0211] Favorite ingredients: chicken, tomatoes

[0212] Disliked food: Onions

[0213] Allergens: Nut-free

[0214] Restrictions: Low calorie

[0215] The output format is:

[0216] Recipe Title

[0217] Materials used

[0218] Cooking Instructions

[0219] Travel time

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

[0221] Step 1:

[0222] The user inputs preferences, allergy information, dietary restrictions, and dietary history into the terminal. The user uses a smartphone application to input information such as, for example, they like chicken, they dislike onions, they are allergic to nuts, or they would like to eat a low-calorie diet. This information is entered into the terminal and sent to the server in an appropriate format. Input: Information about the user's preferences and restrictions. Output: Formatted user information sent to the server.

[0223] Step 2:

[0224] The server stores the received user information in a database. The server analyzes the received information and saves it in the database as profile information for each user. For example, information such as "User ID: 123, likes chicken, dislikes onions, allergy to nuts, prefers low-calorie food" is stored. Input: User information sent from the terminal. Output: User profile saved in the database.

[0225] Step 3:

[0226] The server uses a natural language processing module (e.g., SpaCy) to analyze user preferences, dietary restrictions, and allergy information. The server tokenizes the text data and appropriately tags it to semantically understand each user's preferences and restrictions. For example, preferences and restrictions for ingredients such as "chicken," "onions," and "nuts" are analyzed. Input: User profile stored in a database. Output: Analyzed preference and restriction information.

[0227] Step 4:

[0228] The server runs a recipe generation algorithm (generative AI model) based on the analysis results to generate the optimal recipe for the user. The server uses the analyzed data as prompts to input into the generative AI model. For example, a recipe is generated based on a prompt such as "User ID: 123, Favorite ingredients: Chicken, Avoided ingredients: Onion, Nut allergy, Low calorie." Input: Analyzed preferences and restriction information. Output: Generated customized recipe.

[0229] Step 5:

[0230] The server uses natural language generation AI to describe the generated recipe in detail and sends it to the device. The server then describes each step of the generated recipe, the list of ingredients, the time required, and important points in natural language in detail and sends it to the user's device. For example, a "low-calorie recipe using chicken and tomatoes" is sent along with detailed instructions. Input: The generated customized recipe. Output: A detailed recipe document sent to the user's device.

[0231] Step 6:

[0232] The device displays the generated recipe. The recipe sent to the user's device is displayed through the application. The user checks the recipe, prepares the necessary ingredients, and starts cooking. For example, "Low-calorie dish using chicken and tomatoes" is displayed. Input: Detailed recipe sent from the server. Output: Recipe displayed on the device.

[0233] Step 7:

[0234] The server searches for suppliers that offer the proposed dishes based on the generated recipe and suggests them to the terminal. The server searches a database of restaurants and delivery services to suggest suppliers that offer dishes that match the user's preferences and restrictions. For example, it may suggest to the user information such as "nearby Restaurant A offers this dish." Input: Generated recipe and supplier database. Output: Supplier suggestion information.

[0235] Step 8:

[0236] The user places an order directly from the suggested supplier. The user orders food directly from the suggested restaurant or delivery service through the application. For example, a user can "order a low-calorie menu item with chicken and tomatoes from Restaurant A." Input: Supplier information. Output: Order confirmation information.

[0237] Step 9:

[0238] The user inputs feedback about the recipe into the terminal and sends it to the server. After cooking or ordering, the user inputs their opinions and thoughts about the recipe and sends it to the server via the terminal. For example, feedback such as "It was delicious, but I wish it was a little more spiced" is input. Input: User feedback information. Output: Feedback sent to the server.

[0239] Step 10:

[0240] The server stores the received feedback in a database and analyzes it using a machine learning algorithm (e.g., TensorFlow). The server stores the feedback data in a database and analyzes it using a machine learning algorithm to optimize the recipe generation algorithm for future uses. Input: Feedback information sent by the user. Output: Analyzed feedback and optimized recipe generation algorithm.

[0241] Step 11:

[0242] The next recipe is generated based on the optimized recipe generation algorithm and provided to the user. The server uses the optimized recipe generation algorithm based on the feedback to generate subsequent recipes and provide more personalized suggestions to the user. Input: Optimized recipe generation algorithm. Output: Next customized recipe.

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

[0244] The present invention combines a system that provides original recipes based on a user's preferences, dietary restrictions, allergy information, and dietary history with an emotion engine that recognizes the user's emotions. By taking the user's emotional state into account, the system can provide more personalized recipes.

[0245] System Overview

[0246] The system consists of a device used by the user, a server that supports it, and an emotion engine. Users input profile information such as preferences, dietary restrictions, allergies, and dietary history through their device. At the same time, the emotion engine recognizes the user's emotions and collects that information. This information is sent to the server, which generates recipes based on that information and also receives feedback and makes improvements.

[0247] Program processing

[0248] User: The user first launches the application and logs in. They enter profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I prefer a low-calorie diet." The application also reads the user's emotions through facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[0249] Device: The entered profile information and emotion information is sent to the server using a common data format such as JSON.

[0250] Server: Stores the received profile information and emotion information in a database. A unique ID is assigned to each user, and the profile information and emotion information are classified and organized.

[0251] Server: Analyzes profile information and emotional information using a natural language processing module and emotion engine. From the information, the server identifies the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[0252] Server: Runs a recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe." The recipe's difficulty, time required, and availability of ingredients are also taken into account.

[0253] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[0254] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[0255] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[0256] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[0257] Terminal: After cooking, a rating form is displayed to the user. A star rating (1 to 5 stars) and a comment input field are provided. The user's feelings after cooking are also collected again.

[0258] User: Enter feedback about the cooking. For example, enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send another emotional response.

[0259] Terminal: Sends the input feedback and emotion information to the server. Feedback data is also sent in JSON format.

[0260] Server: Stores the received feedback and emotional information in a database and analyzes it. It identifies common comments and evaluation points based on the feedback content and emotional information.

[0261] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[0262] In this way, the present invention provides customized recipes based on a user's preferences, dietary restrictions, allergy information, and even emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

[0263] The processing flow will be explained below.

[0264] Step 1:

[0265] User: Launches the application and logs in. Enters profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I would like a low-calorie diet." At the same time, the emotion engine obtains the user's emotions through facial recognition and voice analysis, and acquires emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[0266] Step 2:

[0267] Device: The entered profile information and emotion information is sent to the server using a common data format such as JSON.

[0268] Step 3:

[0269] Server: Stores the received profile information and emotion information in a database. A unique ID is assigned to each user, and the profile information and emotion information are classified and organized.

[0270] Step 4:

[0271] Server: Analyzes profile information and emotional information using a natural language processing module and emotion engine. From the information, the server identifies the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[0272] Step 5:

[0273] Server: Runs a recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe." The recipe's difficulty, time required, and availability of ingredients are also taken into account.

[0274] Step 6:

[0275] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[0276] Step 7:

[0277] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[0278] Step 8:

[0279] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[0280] Step 9:

[0281] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[0282] Step 10:

[0283] Terminal: After cooking, a rating form is displayed to the user. A star rating (1 to 5 stars) and a comment input field are provided. The user's feelings after cooking are also collected again.

[0284] Step 11:

[0285] User: Enter feedback about the cooking. For example, enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send another emotional response.

[0286] Step 12:

[0287] Terminal: Sends the input feedback and emotion information to the server. Feedback data is also sent in JSON format.

[0288] Step 13:

[0289] Server: Stores the received feedback and emotional information in a database and analyzes it. It identifies common comments and evaluation points based on the feedback content and emotional information.

[0290] Step 14:

[0291] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[0292] In this way, the present invention provides customized recipes based on a user's preferences, dietary restrictions, allergy information, and even emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

[0293] Example 2

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

[0295] Conventional recipe provision systems were able to provide personalized recipes based on a user's preferences, dietary restrictions, allergy information, and dietary history, but they did not take into account the user's emotional state, making it difficult to provide recipes that were truly suited to each individual user. In particular, they were unable to take into account the fact that a user's mood and emotional state have a significant impact on appetite and ingredient selection, which limited the improvement of the user experience. In addition, the system was not sufficiently optimized through feedback analysis, and there was a lack of means to improve the system's accuracy.

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

[0297] In this invention, the server includes a means for storing received user information and emotional information in a database, a means for analyzing the user information and emotional information using a natural language processing module and an emotion engine, and a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user. This enables the provision of more personalized recipes that take into account the user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. Furthermore, by analyzing the received feedback and emotional information using a machine learning algorithm and reflecting this in the next recipe generation, the system can be continuously optimized and the user experience can be improved.

[0298] "User information" refers to personal profile information such as the user's preferences, dietary restrictions, allergy information, and dietary history.

[0299] "Emotion information" is information that indicates the user's mood or emotional state, such as whether the user is feeling stressed or relaxed.

[0300] A "server" is a computer system that receives, stores, analyzes user information and emotion information, and generates recipes.

[0301] A "natural language processing module" is a software module that analyzes input user information and extracts meaning from it.

[0302] An "emotion engine" is an algorithm or software that analyzes a user's facial recognition and voice data to identify the user's emotional state.

[0303] The "recipe generation algorithm" is an algorithm for generating an optimal recipe based on analyzed user information and emotional information.

[0304] A "natural language generation model" is an AI model that generates analysis results and recipes for users in natural-sounding sentences.

[0305] "Feedback" refers to response information such as user ratings and comments on the provided recipe.

[0306] "Machine learning algorithms" are algorithms used to optimize the performance of the system based on the feedback and sentiment information received.

[0307] This system provides original recipes by combining a user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. This system consists of a terminal used by the user, a server that supports it, and an emotion engine.

[0308] Hardware and software used

[0309] To realize this system, the following hardware and software are used:

[0310] Device: User device such as smartphone, tablet, or PC

[0311] Server: Cloud server or on-premise server

[0312] Database: Relational database such as MySQL or PostgreSQL

[0313] Natural language processing modules: Libraries such as SpaCy and NLTK

[0314] Emotion engine: facial recognition software, voice analysis tools

[0315] Recipe generation algorithms: Python scripts, algorithm libraries

[0316] Natural language generation models: AI models such as GPT-4

[0317] Machine learning algorithms: Libraries such as Scikit-Learn and TensorFlow

[0318] Program processing and specific examples

[0319] User: The user first launches the application and logs in. They enter profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I'd like a low-calorie diet." The application also reads the user's emotions through facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[0320] Device: The device sends the entered profile information and emotion information to the server. The data is sent in a common data format such as JSON.

[0321] Server: The server stores the received profile information and emotion information in a database. It assigns a unique ID to each user and organizes the profile information and emotion information.

[0322] Server: The profile information and sentiment information are then analyzed by a natural language processing module and sentiment engine, which identifies the user's preferences, allergies, dietary restrictions, and emotional state.

[0323] Server: Runs the recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[0324] Server: The selected recipes are converted into text using natural language generation AI (e.g., GPT-4), which then details the recipe steps, ingredient list, cooking time, and precautions.

[0325] Server: Sends the generated recipe data to the user's device.

[0326] Device: The device displays the submitted recipe in a visually friendly format, including the recipe title, ingredients list, cooking steps, cooking time, difficulty level, etc.

[0327] User: The user prepares ingredients based on the displayed recipe and begins cooking. While cooking, the user continues to follow the instructions while referring to the device.

[0328] Terminal: After cooking, the terminal displays a rating form to the user, providing a star rating (1-5 stars) and a comment input field, and also collecting emotional information.

[0329] User: Enter feedback. Example: Enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send emotional information again.

[0330] Device: Sends rating and emotion information to the server. Feedback data is also sent in JSON format.

[0331] Server: The received feedback and emotional information are stored in a database and analyzed. Common comments and evaluation points are identified based on the feedback content and emotional information.

[0332] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback information and sentiment information. This information is reflected in future recipe suggestions.

[0333] Prompt Sentence Examples

[0334] As a concrete example, consider a case where a user wants a recipe that is low in calories and has a stress-relieving effect. Here is an example prompt to input to the generative AI model:

[0335] User Preference Profile:

[0336] Favorite ingredients: chicken, tomatoes

[0337] Disliked food: Onions

[0338] Allergens: nuts

[0339] Dietary restrictions: Low calorie

[0340] Emotional state: Stressed

[0341] Please suggest a recipe that meets these criteria, including a specific ingredient list, cooking instructions, cooking time, and any warnings.

[0342] In this way, the system can provide customized recipes based on the user's preferences, dietary restrictions, allergy information, and even emotional state, and use that feedback to improve the system's accuracy.

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

[0344] Step 1:

[0345] User: A user launches an application and logs in.

[0346] Input: User ID, Password

[0347] Output: Login success or failure message

[0348] Specific operation: The user starts the application and enters their user ID and password on the login screen. When they press the "Login" button, the device sends the entered information to the server. The server compares it with the user information database and returns a message to the device indicating whether the login was successful. If a success message is displayed, the user can proceed to the next step.

[0349] Step 2:

[0350] User: Enters preferences, dietary restrictions, allergy information, past dietary history, and emotional state.

[0351] Input: food preferences, dietary restrictions, allergy information, past dietary information, emotional information

[0352] Output: Confirmation message for input contents

[0353] How it works: Users fill out a form in the application to enter their preferences, dietary restrictions, allergies, and dietary history, and provide their emotional state using facial recognition and voice input. When they press the "Send" button, the device sends this information to the server in JSON format.

[0354] Step 3:

[0355] Terminal: Sends the entered profile information and emotion information to the server.

[0356] Input: JSON format profile information, emotion information

[0357] Output: Message indicating that the data sent to the server has been sent successfully

[0358] Specific operation: JSON data containing profile information and emotion information is sent to the server via HTTPS. After sending, the device displays a message to the user indicating completion of sending.

[0359] Step 4:

[0360] Server: Stores the received data in a database.

[0361] Input: JSON format profile information, emotion information

[0362] Output: Database update completion message

[0363] Specific operation: The server parses the received JSON data and stores it in a relational database such as MySQL or PostgreSQL. A unique ID is assigned to each user data item and the data is properly organized. A completion message is generated when the database update is complete.

[0364] Step 5:

[0365] Server: Analyzes user information and emotional information using a natural language processing module and emotion engine.

[0366] Input: Profile information and emotion information stored in the database

[0367] Output: Analysis results (user preferences, allergies, dietary restrictions, emotional state)

[0368] How it works: Using natural language processing modules (e.g., SpaCy or NLTK) and emotion engines (facial recognition software, speech analysis tools), the system analyzes profile information and emotional information. The results of the analysis are used to identify and extract new user preferences, allergies, dietary restrictions, and emotional state, and store them in a database.

[0369] Step 6:

[0370] Server: Executes the recipe generation algorithm based on the analysis results.

[0371] Input: Analysis results (user preferences, allergies, dietary restrictions, emotional state)

[0372] Output: Generated recipe information

[0373] How it works: Using a recipe generation algorithm (Python script or algorithm library), the system searches the database for the best recipe based on the analysis results and generates a customized recipe for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[0374] Step 7:

[0375] Server: Uses natural language generation AI to write down the details of the generated recipe.

[0376] Input: Generated recipe information

[0377] Output: Written recipe details

[0378] What it does: It uses a natural language generation model (e.g., GPT-4) to generate natural-sounding details for the generated recipe, including information like ingredient lists, cooking instructions, cooking times, and warnings.

[0379] Step 8:

[0380] Server: Sends the generated recipe data to the user's device.

[0381] Input: Written recipe details

[0382] Output: A message to the terminal indicating that transmission is complete

[0383] Specific operation: The generated recipe data is converted to JSON format and sent to the user's device. A transmission completion message is generated on the server side.

[0384] Step 9:

[0385] Terminal: Displays submitted recipes in a visually friendly format.

[0386] Input: Recipe data in JSON format

[0387] Output: Recipe display screen

[0388] Specific operation: The device parses the JSON format recipe data received and displays the recipe information visually in an easy-to-understand manner on a GUI (Graphical User Interface). This is implemented using libraries such as Vue.js and React.

[0389] Step 10:

[0390] User: Prepare ingredients and start cooking.

[0391] Input: Recipe details

[0392] Output: Finished dish

[0393] Specific operation: The user gathers the necessary ingredients based on the displayed recipe and begins cooking according to the instructions. During cooking, the user refers to the device screen for each step and uses the "Next" button to proceed through the steps.

[0394] Step 11:

[0395] Terminal: Display the evaluation form after cooking.

[0396] Input: None (cooking completion trigger)

[0397] Output:Evaluation form display

[0398] Specific operation: Once cooking is complete, the device will automatically display a rating form in a pop-up window, etc. The rating form includes a star rating (1-5 stars) and a comment input field, as well as an option to obtain additional emotional information.

[0399] Step 12:

[0400] Users: Enter your rating and feedback.

[0401] Input: Rating (star rating and comments), sentiment information

[0402] Output: Sending rating and sentiment data

[0403] Specific operation: The user enters a star rating and a comment in the rating form, and then presses the "Submit" button to send the feedback and emotional information. The content is sent from the device to the server in JSON format.

[0404] Step 13:

[0405] Terminal: Sends ratings and emotion information to the server.

[0406] Input: Evaluation information, emotion information

[0407] Output: Message sent to server

[0408] Specific operation: The input rating and emotion information is converted into JSON format and sent to the server using the HTTPS protocol. After the transmission is complete, the device displays a completion message.

[0409] Step 14:

[0410] Server: Stores the received ratings and emotion information in a database and performs analysis.

[0411] Input: Feedback and sentiment information in JSON format

[0412] Output: Analysis complete message

[0413] Specific operation: The received feedback and emotional information are stored in a database, and analyzed using the analysis module. Common comments and evaluation points are identified from the feedback content and emotional information, and the analysis results are stored in the database.

[0414] Step 15:

[0415] Server: Optimizes the recipe generation algorithm using machine learning algorithms.

[0416] Input: Analysis results, feedback information, emotion information

[0417] Output: Optimized recipe generation algorithm

[0418] How it works: Using machine learning algorithms (e.g., Scikit-Learn or TensorFlow), the recipe generation algorithm is optimized based on the analysis results, feedback, and sentiment information. Once the optimization is complete, the algorithm is reflected in the next recipe generation.

[0419] (Application example 2)

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

[0421] Conventional recipe suggestion systems generate recipes based only on the user's preferences, dietary restrictions, allergy information, and dietary history, resulting in insufficient personalization based on the user's emotional state. Furthermore, there are limitations to their application in brick-and-mortar establishments such as restaurants, and challenges remain in improving motivation and satisfaction in line with the user's emotions. In particular, there is a need for systems that can provide optimal meal menus tailored to the customer's emotional state.

[0422] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for inputting a user's preferences, dietary restrictions, allergy information, and dietary history; means for transmitting the input information to the server; means for storing the received user information in a database; means for analyzing the user information using a natural language processing module; means for executing a recipe generation algorithm based on the analysis results and generating a recipe optimal for the user; means for transmitting the generated recipe to the user's terminal; means for displaying the transmitted recipe on the user's terminal; means for transmitting user feedback to the server; means for storing and analyzing the received feedback in a database; means for optimizing the recipe generation algorithm based on the analysis results; an emotion recognition engine for recognizing the user's emotional state; means for transmitting the recognized emotion information to the server; and means for generating a recipe appropriate for the user's emotional state based on the emotion information and profile information. This enables personalized recipe suggestions based on the user's emotional state, thereby improving customer satisfaction even in physical stores.

[0423] "User preferences" refers to the user's preferred foods, ingredients, seasoning preferences, etc.

[0424] "Dietary Restrictions" refers to restrictions on foods or nutrients that a user should avoid for health reasons or personal preferences.

[0425] "Allergy information" is information about foods and ingredients that may cause a user an allergic reaction.

[0426] "Dietary history" is information about the contents of meals the user has eaten in the past and their history.

[0427] An "emotion recognition engine" is a system that recognizes a user's emotional state from their facial expressions, voice, etc., and converts it into digital data.

[0428] "Profile information" is comprehensive personal information such as the user's preferences, dietary restrictions, allergy information, and dietary history.

[0429] A "natural language processing module" refers to a program or algorithm that analyzes input text information and understands its meaning.

[0430] A "recipe generation algorithm" is a calculation method for generating an optimal recipe based on a user's profile information.

[0431] "Feedback" refers to ratings and comments that users make about recipes and services provided.

[0432] A "machine learning algorithm" is an algorithm that improves system performance based on feedback and usage history.

[0433] The "database" is a system for efficiently managing and storing user information, profile information, generated recipes, feedback, etc.

[0434] This invention relates to a system that provides optimal recipes based on a user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. This system is composed of a terminal used by the user, a server, and an emotion recognition engine.

[0435] First, the user launches the application on a device such as a smartphone or tablet and logs in. After that, the user enters their preferences, dietary restrictions, allergy information, and dietary history. An emotion recognition engine then recognizes emotions from the user's face and voice, and this information is also acquired. This information is then sent from the device to the server in JSON format or similar.

[0436] The information received by the server is stored in a database, where it is categorized and organized by assigning a unique ID to each user. The server then uses a natural language processing module and an emotion recognition engine to analyze the user's profile information and emotional information. Based on the analysis results, a recipe generation algorithm is executed to search for and customize the optimal recipe. For example, a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe" is generated. The recipe's difficulty, required time, and ease of obtaining ingredients are also taken into consideration.

[0437] The generated recipe is then written in detail using natural language generation AI, including specific recipe steps, ingredient lists, cooking times, and important notes. This information is then sent back to the device in JSON format, where users can view it in a visually easy-to-understand format.

[0438] The user creates a dish based on the recipe and is presented with a feedback form to rate the results. A star rating (1-5 stars) and a comment input field are provided, and emotional information after cooking is also collected. This feedback and emotional information is again sent from the device to the server. The server stores the received feedback in a database and analyzes it. Based on the results of this analysis, a machine learning algorithm optimizes the recipe generation algorithm and reflects it in future recipe suggestions.

[0439] For example, if a user's profile information is "Favorite ingredients are chicken and tomatoes, least favorite ingredients are onions, allergies are nuts, and a low-calorie diet is desired," and the emotion recognition engine recognizes that the user is "feeling good today," it will suggest a "low-calorie chicken and tomato recipe."An example of a prompt sentence is as follows:

[0440] Example prompt sentence:

[0441] User profile: Favorite foods are chicken and tomatoes, dislikes onions, allergies to nuts. Prefers low-calorie meals.

[0442] Today's feeling: I feel good.

[0443] Generate optimal recipes based on this profile and sentiment.

[0444] In this way, the present invention provides recipes customized based on the user's preferences, dietary restrictions, allergy information, and emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

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

[0446] Step 1:

[0447] The user launches the application on their device and logs in. The user enters their preferences, dietary restrictions, allergy information, and dietary history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I prefer a low-calorie diet." The input data is converted to JSON format.

[0448] Input: User preferences, dietary restrictions, allergy information, dietary history

[0449] Output: Profile information in JSON format

[0450] Step 2:

[0451] The emotion recognition engine reads the user's emotions from facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[0452] Input: User's facial image or voice data

[0453] Output: Emotional information

[0454] Step 3:

[0455] The device sends profile information (step 1) and emotion information (step 2) to the server. The data is sent in JSON format.

[0456] Input: JSON format profile information, emotion information

[0457] Output: Send data to the server

[0458] Step 4:

[0459] The server stores the received profile information and emotion information in a database. Each user is assigned a unique ID and classified and organized.

[0460] Input: JSON format profile information, emotion information

[0461] Output: Store in database

[0462] Step 5:

[0463] The server analyzes the received data using a natural language processing module and an emotion recognition engine, thereby identifying the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[0464] Input: Profile information and emotion information stored in the database

[0465] Output: Analysis results (user preferences, allergy information, dietary restrictions, emotional state)

[0466] Step 6:

[0467] The server runs a recipe generation algorithm based on the analysis results, searching for suitable recipes from a database and customizing them for the user. For example, it generates a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[0468] Input: Analysis results

[0469] Output: Customized recipe data

[0470] Step 7:

[0471] The server uses natural language generation AI to translate the details of the generated recipe into text, including recipe steps, ingredient list, cooking time, and important notes.

[0472] Input: Customized recipe data

[0473] Output: A written recipe

[0474] Step 8:

[0475] The server sends the generated recipe to the user's terminal, and sends the recipe data in response to the request.

[0476] Input: Written recipe

[0477] Output: Send recipe to terminal

[0478] Step 9:

[0479] The device displays the recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty level, and other information in a visually easy-to-understand format.

[0480] Input: Data to send to the terminal

[0481] Output: A visual representation of the recipe

[0482] Step 10:

[0483] The user checks the displayed recipe, prepares the necessary ingredients, and begins cooking. While cooking, the user continues to follow the instructions while referring to the device.

[0484] Input: Display recipe to user

[0485] Output: User cooking action

[0486] Step 11:

[0487] After cooking, the device displays a rating form to the user, providing a star rating (1 to 5 stars) and a comment input field. The device also collects the user's feelings after cooking.

[0488] Input: User operation after recipe cooking

[0489] Output: Evaluation form, retrieved emotional information

[0490] Step 12:

[0491] The user enters feedback about the cooking, for example, "4 stars, it was delicious but I'd like to add a little spice," and also submits emotional information.

[0492] Input: Evaluation form, comments, sentiment information

[0493] Output: Feedback data

[0494] Step 13:

[0495] The device sends the input feedback and emotion information to the server, and the data is again sent in JSON format.

[0496] Input: Feedback data

[0497] Output: Send data to the server

[0498] Step 14:

[0499] The server stores the received feedback and emotional information in a database and analyzes it. It identifies frequently occurring comments and evaluation points based on the feedback content and emotional information.

[0500] Input: Feedback data, emotional information

[0501] Output: Parsed data

[0502] Step 15:

[0503] The server uses a machine learning algorithm to optimize the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[0504] Input: Parsed data

[0505] Output: Optimized recipe generation algorithm

[0506] Through these processing steps, the present invention is able to provide and continually improve personalized recipes that take into account a user's preferences, dietary restrictions, allergy information, and emotional state.

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

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

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

[0510] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0523] The present invention is a system that provides original recipes that take into account the user's preferences, dietary restrictions, allergy information, and dietary history. This system mainly involves a process in which the user inputs information through a terminal, the server generates recipes based on that information, and then receives feedback and makes improvements.

[0524] System Overview

[0525] The system consists of a device used by the user and a server that supports it. Users enter profile information such as preferences, dietary restrictions, allergies, and dietary history through their own device. This information is sent to the server, which stores it in a database. Here, a natural language processing module analyzes the user information and runs a recipe generation algorithm to generate the optimal recipe for the user.

[0526] Program processing

[0527] User: The user first launches the application and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, they can enter chicken as their favorite food, onions as their least favorite food, nuts as their allergic food, and request a low-calorie diet.

[0528] Terminal: The entered information is sent from the user's terminal to the server. The terminal sends this information in the appropriate format so that the server can receive it.

[0529] Server: The server stores the received information in a database, which stores each user's profile information. A natural language processing module then analyzes the stored information to identify the user's preferences and restrictions.

[0530] Server: The recipe generation algorithm is executed based on the analysis results. The algorithm searches the database for relevant recipes and customizes them to suit the user's preferences and restrictions. For example, a "low-calorie recipe using chicken and tomatoes" may be generated. The algorithm also takes into account the difficulty of the recipe, the time required, and the difficulty of obtaining ingredients, so recipes that are easy for beginners to follow are provided.

[0531] Server: The generated recipe is described in detail by natural language generation AI and sent to the user's device.

[0532] Device: The generated recipe is displayed on the user's device. The user checks the recipe, prepares the necessary ingredients, and starts cooking. The recipe includes cooking instructions, a list of ingredients, cooking time, and important notes.

[0533] User: After cooking is complete, the user can provide feedback on the recipe. For example, they can comment, "It was delicious, but I wish it had a few more spices."

[0534] Terminal: The feedback information is sent back to the server, which stores it in a database.

[0535] Server: The received feedback is analyzed using a machine learning algorithm. The recipe generation algorithm is adjusted based on the feedback and reflected in future recipe generation. This allows the system to provide recipes that are more tailored to the user's preferences.

[0536] In this way, the present invention is a system that can generate and provide optimal original recipes taking into account the user's preferences, dietary restrictions, and allergy information. Furthermore, it is possible to continuously improve the recipe generation algorithm based on user feedback, realizing an optimal diet for each individual user.

[0537] The processing flow will be explained below.

[0538] Step 1:

[0539] User: Launches the application and logs in. Enters profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite foods are chicken and tomatoes, my least favorite foods are onions, I'm allergic to nuts, and I prefer a low-calorie diet."

[0540] Step 2:

[0541] Device: The entered profile information is sent to the server using a common data format such as JSON.

[0542] Step 3:

[0543] Server: Stores the received profile information in a database. A unique ID is assigned to each user, and the profile information is categorized and organized.

[0544] Step 4:

[0545] Server: Analyzes profile information using a natural language processing module, identifies user preferences, allergies, and dietary restrictions from the information, and extracts analysis results.

[0546] Step 5:

[0547] Server: Runs the recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. This takes into account the difficulty of the recipe, the time required, and the ease of obtaining ingredients. For example, it selects a "low-calorie recipe with chicken and tomatoes."

[0548] Step 6:

[0549] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[0550] Step 7:

[0551] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[0552] Step 8:

[0553] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[0554] Step 9:

[0555] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[0556] Step 10:

[0557] Terminal: After cooking, a rating form is displayed to the user, providing a star rating (1 to 5 stars) and a comment input field.

[0558] Step 11:

[0559] User: Enter feedback about the cooking. For example, enter a comment like "4 stars, it was delicious but I'd like it to be a little spiced up."

[0560] Step 12:

[0561] Terminal: Sends the entered feedback to the server. Feedback data is also sent in JSON format.

[0562] Step 13:

[0563] Server: Stores the received feedback in a database and analyzes it. It identifies common comments and evaluation points from the feedback.

[0564] Step 14:

[0565] Server: The machine learning algorithm optimizes the recipe generation algorithm based on the feedback information. The feedback is used as learning data to be reflected in future recipe generation.

[0566] In this way, the present invention provides recipes that are customized based on a user's preferences, dietary restrictions, and allergy information, and can continuously improve their accuracy based on user feedback.

[0567] Example 1

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

[0569] Conventional recipe provision systems have had the problem of being unable to provide original recipes that fully take into account the user's preferences, dietary restrictions, allergy information, and dietary history. Furthermore, there were few systems that could efficiently analyze user feedback and reflect it in the next recipe generation. This made it difficult to provide recipes that were suited to each individual user, and there was a need to improve user satisfaction.

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

[0571] In this invention, the server includes a means for storing received user information in a database, a means for analyzing the user information using a natural language processing module, a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user, and a means for describing the generated recipe in detail using a natural language generation model and transmitting the description to the user's terminal. This makes it possible to provide optimal recipes that take into account the user's individual preferences and dietary restrictions. In addition, user feedback can be analyzed using a machine learning algorithm and reflected in the next recipe generation, enabling continuous system optimization.

[0572] "User" refers to a person who uses a terminal to input information such as preferences, dietary restrictions, allergy information, and dietary history, and receives the optimal recipe from the system.

[0573] "Preferences" is information that indicates the specific ingredients or types of dishes that a user likes.

[0574] "Dietary Restrictions" refers to information about specific ingredients or foodstuffs that a user should avoid consuming.

[0575] "Allergy information" is information about specific ingredients to which a user may have an allergic reaction.

[0576] "Dietary history" is information about a record of meals the user has taken in the past and their evaluations.

[0577] "Terminal" refers to the hardware device through which a user inputs information and checks recipes, such as a smartphone, tablet, or PC.

[0578] A "server" is a computer system that receives information sent by users, stores it in a database, and performs analysis and recipe generation.

[0579] A "database" is a digital storage system for storing user information, generated recipes, feedback information, and the like.

[0580] A "natural language processing module" is a software module for analyzing received user information and understanding text data.

[0581] A "recipe generation algorithm" is a series of calculations used to generate optimal recipes based on a user's preferences, dietary restrictions, etc.

[0582] A "natural language generation model" is an AI technology that describes the generated recipe in detail and provides it to the user in natural language.

[0583] "Feedback" refers to comments that users can send to the system, such as their thoughts, ratings, and suggestions for improvement regarding the provided recipe.

[0584] A "machine learning algorithm" is a learning method that analyzes user feedback and reflects it in the next recipe generation.

[0585] The present invention is a system that provides original recipes that take into account the user's preferences, dietary restrictions, allergy information, and dietary history. This system involves a process in which the user inputs information through a terminal, the server generates recipes based on that information, and the system receives feedback and makes improvements.

[0586] Hardware and software used

[0587] Device: The device used by the user, such as a smartphone, tablet, or PC (e.g., iOS, Android, Windows, macOS).

[0588] Server: Cloud server (e.g. AWS, Google Cloud, Microsoft Azure).

[0589] software:

[0590] Natural language processing modules (e.g. spaCy, NLTK).

[0591] Recipe generation algorithms (custom algorithms, machine learning models).

[0592] Database (e.g. MySQL, PostgreSQL).

[0593] Natural language generation AI (e.g. GPT-3, ChatGPT).

[0594] Program Processing Details

[0595] User: First, the user launches a dedicated application on their device and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, the user might fill in the input form with "Favorite food: chicken," "Disliked food: onion," "Allergy: nuts," "Desired: low calorie," etc.

[0596] Terminal: The terminal encrypts the information entered by the user using HTTPS and sends it to the server via a REST API. The terminal converts the information into JSON format and sends a request to the appropriate API endpoint.

[0597] Server: The server analyzes the received information and stores it in a database. The database stores each user's profile information. The server then analyzes the user information using a natural language processing module (e.g., spaCy), tokenizing the text data and identifying keywords such as "favorite ingredients" or "allergies." It then identifies the user's preferences and restrictions and prepares the analysis results.

[0598] Server: Runs a recipe generation algorithm based on the analysis results. This algorithm searches the database for suitable recipes. For example, it prioritizes recipes that use "chicken and tomato" or low-calorie recipes. The generated recipe is then written in detailed text using natural language generation AI (e.g., GPT-3). The generation AI generates the recipe name "Low-calorie chicken and tomato salad," along with cooking instructions, ingredient list, required time, and precautions.

[0599] Server: The generated recipe is sent to the user's device via the REST API in JSON format.

[0600] Device: The user's device receives the data from the server and displays the recipe on the app's UI. The user can check this information, prepare the necessary ingredients, and start cooking.

[0601] User: After cooking is complete, the user can enter feedback about the recipe through the application. For example, they can comment in the text box, "It was delicious, but I would like it to be a little more spiced."

[0602] Terminal: The feedback information entered by the user is again sent from the terminal to the server. This process is also encrypted using HTTPS and sent via the REST API, just like the information sending step.

[0603] Server: The received feedback is analyzed by a machine learning algorithm. The server analyzes the feedback using a natural language processing module and classifies the feedback content by element. For example, it extracts positive comments such as "delicious" and "I'd like to add some spices" as well as requests for improvement. The recipe generation algorithm is adjusted based on the analysis results. The feedback content is added as a new data point to the algorithm's training data, and the model is retrained, so that it is reflected in future recipe generation.

[0604] Examples of concrete examples and prompts

[0605] Examples:

[0606] User: "I like chicken, hate onions, and I'm allergic to nuts. I'd also like to eat a low-calorie diet."

[0607] Recipe generated from the server: "Low-calorie salad with chicken and tomatoes. Cooking instructions: 1. Boil the chicken. 2. Chop the tomatoes. 3. Mix the chicken and tomatoes and toss with olive oil."

[0608] Example prompt for generative AI model:

[0609] User Information:

[0610] Favorite food: Chicken

[0611] Disliked food: Onions

[0612] Allergies: Nuts

[0613] Desired: Low calorie

[0614] Use this information to generate low-calorie recipes tailored to your users.

[0615] In this way, the present invention creates a system that can generate and provide optimal original recipes taking into account the user's preferences, dietary restrictions, and allergy information. Furthermore, it is possible to continuously improve the recipe generation algorithm based on user feedback, realizing an optimized diet for each individual user.

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

[0617] Step 1:

[0618] Information input step

[0619] User: First, the user launches a dedicated application on their device and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, the user might fill in the input form with "Favorite food: chicken," "Disliked food: onion," "Allergy: nuts," "Want: low calories," etc. This information becomes data used to communicate the user's individual preferences and restrictions to the system.

[0620] Step 2:

[0621] Information transmission steps

[0622] Terminal: The terminal encrypts the information entered by the user using HTTPS and sends it to the server via the REST API. The terminal converts the information into JSON format and sends a request to the appropriate API endpoint. The input data (preferences, allergy information, dietary restrictions, dietary history) is encrypted and sent to the server.

[0623] Step 3:

[0624] Information storage step

[0625] Server: The server parses the received information and stores it in a database. This information includes the user's preferences, allergy information, dietary restrictions, and past dietary history. The database stores profile information for each user. The received input data is parsed and inserted into the "users" table using a database manipulation library (e.g., SQLAlchemy).

[0626] Step 4:

[0627] Information Analysis Step

[0628] Server: The server uses a natural language processing module (e.g., spaCy) to analyze user information. For example, it tokenizes text data and identifies keywords such as "favorite ingredients" and "allergies." As a result, the user's preferences and restrictions become clear. The input data is user information (preferences, allergy information, dietary restrictions), and this data is analyzed to output results such as "favorite ingredients: chicken" and "allergies: nuts."

[0629] Step 5:

[0630] Recipe Generation Steps

[0631] Server: Runs a recipe generation algorithm based on the analysis results. This algorithm searches the database for suitable recipes and customizes them to fit the user's preferences and restrictions. For example, it may prioritize recipes using "chicken and tomatoes" or low-calorie recipes. The analysis results are provided as input data, and a customized recipe is output based on them.

[0632] Step 6:

[0633] Recipe Description Steps

[0634] Server: The generated recipe is described in detail as text using natural language generation AI (e.g., GPT-3). The generation AI creates information such as the recipe name "Low-calorie chicken and tomato salad," cooking instructions, ingredient list, required time, and precautions. The input data is the analysis results and the generated recipe, and a detailed recipe is output based on this.

[0635] Step 7:

[0636] Recipe Send and View Steps

[0637] Server: The generated recipe is sent to the user's device. This is also sent in JSON format via the REST API. The generated recipe data is entered and converted into the format to be sent.

[0638] Device: The user's device receives the data from the server and displays it on the app's UI. The user can check the recipe details and start cooking through this UI. The received JSON data is converted into a format that is displayed in the UI.

[0639] Step 8:

[0640] Feedback Input Step

[0641] User: After cooking is complete, the user enters feedback about the recipe through the application. For example, they might comment in a text box, "It was delicious, but I'd like it to have a bit more spice." This feedback information becomes data to improve the recipe generation for future recipes.

[0642] Step 9:

[0643] Feedback submission step

[0644] Terminal: The feedback information entered by the user is again sent from the terminal to the server. This process, like the information sending step, is encrypted using HTTPS and sent via the REST API. The input data is the user's feedback content, which is encrypted and sent to the server.

[0645] Step 10:

[0646] Feedback Analysis Step

[0647] Server: The received feedback is analyzed using a machine learning algorithm. The server analyzes the feedback using a natural language processing module and classifies the feedback content by element. For example, it extracts positive comments such as "delicious" and "I'd like to add some spice" as well as requests for improvement. The feedback data is input and the content is output by category.

[0648] Step 11:

[0649] Algorithm Adjustment Steps

[0650] Server: Adjusts the recipe generation algorithm based on the analysis results. The feedback content is added as a new data point to the algorithm's training data, and the model is retrained. This is reflected in future recipe generation. The feedback analysis results are input, and an optimized algorithm is output.

[0651] Step 12:

[0652] Optimized recipe provision steps

[0653] Server: Based on user feedback, the algorithm is adjusted so that future recipes are more tailored to the individual user. This allows the user to receive recipes that are increasingly tailored to them. Using the optimized algorithm, new recipes are generated and output.

[0654] (Application example 1)

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

[0656] Many modern food delivery services offer a standard menu without adequately considering individual requirements such as user preferences, dietary restrictions, and allergy information. This makes it difficult for users to choose the right dish, and they may suggest dishes that do not accommodate allergies or dietary restrictions. This results in lower user satisfaction and a decrease in the frequency of use of food delivery services. Furthermore, the lack of a mechanism for incorporating feedback after an order to improve suggestions for the next order slows down the improvement of the user experience.

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

[0658] In this invention, the server includes means for inputting a user's preferences, dietary restrictions, allergy information, and dietary history, means for transmitting the input information to the server, and means for storing the received user information in a database. This enables the generation of optimal recipes that take into account the user's individual requirements. The server further includes means for analyzing the user information using a natural language processing module, means for executing a recipe generation algorithm based on the analysis results to generate an optimal recipe for the user, means for transmitting the generated recipe to the user's terminal, means for displaying the transmitted recipe on the user's terminal, and means for transmitting feedback from the user to the server. The server also includes means for storing and analyzing the received feedback in a database, means for optimizing the recipe generation algorithm based on the analysis results, means for searching for and suggesting suppliers that provide suggested dishes based on the generated recipe, and means for directly ordering from the suggested suppliers. This allows users to easily order dishes that suit their preferences and dietary restrictions, and the next suggestions are further optimized based on the feedback, significantly improving the user experience.

[0659] "User preferences" refer to the characteristics of ingredients and dishes that the user likes to eat.

[0660] "Dietary restrictions" are restrictions on ingredients or nutrients that a user wants to avoid for reasons such as health or dieting.

[0661] "Allergy information" is information about ingredients that may cause an allergic reaction to the user.

[0662] "Dietary history" is a record of meals that a user has eaten in the past.

[0663] A "server" is a computer system that receives, stores, and analyzes user input information, and generates and provides recipes.

[0664] A "natural language processing module" is a technology for analyzing information entered by a user and understanding its meaning.

[0665] A "recipe generation algorithm" is a method for automatically generating optimal recipes based on a user's preferences and restrictions.

[0666] "Feedback" refers to the user's opinions and impressions about the recipe provided.

[0667] A "supplier" is a restaurant or delivery service provider that provides food to users.

[0668] A "terminal" is a device (e.g., smartphone, tablet) that a user uses to enter information and receive recipe suggestions.

[0669] A "database" is a system for storing and managing user information and feedback within a server.

[0670] "Machine learning algorithms" are technologies that analyze user feedback and improve future recipe suggestions.

[0671] This invention is a system that provides original recipes taking into account a user's preferences, dietary restrictions, allergy information, and dietary history, and further improves the recipes based on feedback. The system is primarily composed of a user terminal and a server. Specific embodiments of this system are described below.

[0672] First, the user inputs their preferences, allergy information, dietary restrictions, past dietary history, etc. into the terminal. For example, if a user likes chicken, dislikes onions, is allergic to nuts, and wishes to eat a low-calorie diet, they input this information into the terminal. The terminal then sends this information in an appropriate format to the server.

[0673] The server stores the received information in a database. The database stores profile information for each user. Next, the server uses a natural language processing module (e.g., SpaCy) to analyze the user information. This analysis identifies the user's preferences and restrictions. For example, "chicken" and "low calorie" are analyzed.

[0674] Based on the analysis results, the server runs a recipe generation algorithm (generative AI model) to generate the optimal recipe for the user. The generated recipe is then described in detail using natural language generation AI and sent to the device. The generated recipe is then displayed on the user's device. The recipe includes cooking instructions, a list of ingredients, required time, and important notes.

[0675] Furthermore, the server searches for and suggests suppliers (restaurants and delivery services) that offer the proposed dishes based on the generated recipe. The user can then place an order directly from the provided supplier. For example, a restaurant that offers a "low-calorie recipe using chicken and tomatoes" is suggested, and the user can then place an order.

[0676] After cooking is complete, the user can enter feedback on the recipe, such as "It was delicious, but I wish it had a bit more spice." This feedback information is sent back to the server, which stores it in a database.

[0677] The received feedback is analyzed by a machine learning algorithm (e.g., TensorFlow) on the server. The recipe generation algorithm is adjusted based on the feedback and reflected in future recipe generation. This allows the system to provide recipes that are more tailored to the user's preferences.

[0678] Hardware / Software used

[0679] Hardware: Smartphones, servers

[0680] Software: Android / iOS applications, Python, Django (web framework), natural language processing modules (e.g., SpaCy), machine learning models (e.g., TensorFlow)

[0681] Specific examples

[0682] User "Yamada Taro" uses the system to search for new recipes. He enters the following information into his profile:

[0683] Favorite ingredients: chicken, tomatoes

[0684] Disliked food: Onions

[0685] Allergies: Nuts

[0686] Dietary restrictions: low calorie

[0687] Generative AI model prompt example

[0688] Here are some example prompts for a generative AI model:

[0689] Based on the profile of user "Yamada Taro", generate low-calorie recipes that meet the following criteria:

[0690] Favorite ingredients: chicken, tomatoes

[0691] Disliked food: Onions

[0692] Allergens: Nut-free

[0693] Restrictions: Low calorie

[0694] The output format is:

[0695] Recipe Title

[0696] Materials used

[0697] Cooking Instructions

[0698] Travel time

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

[0700] Step 1:

[0701] The user inputs preferences, allergy information, dietary restrictions, and dietary history into the terminal. The user uses a smartphone application to input information such as, for example, they like chicken, they dislike onions, they are allergic to nuts, or they would like to eat a low-calorie diet. This information is entered into the terminal and sent to the server in an appropriate format. Input: Information about the user's preferences and restrictions. Output: Formatted user information sent to the server.

[0702] Step 2:

[0703] The server stores the received user information in a database. The server analyzes the received information and saves it in the database as profile information for each user. For example, information such as "User ID: 123, likes chicken, dislikes onions, allergy to nuts, prefers low-calorie food" is stored. Input: User information sent from the terminal. Output: User profile saved in the database.

[0704] Step 3:

[0705] The server uses a natural language processing module (e.g., SpaCy) to analyze user preferences, dietary restrictions, and allergy information. The server tokenizes the text data and appropriately tags it to semantically understand each user's preferences and restrictions. For example, preferences and restrictions for ingredients such as "chicken," "onions," and "nuts" are analyzed. Input: User profile stored in a database. Output: Analyzed preference and restriction information.

[0706] Step 4:

[0707] The server runs a recipe generation algorithm (generative AI model) based on the analysis results to generate the optimal recipe for the user. The server uses the analyzed data as prompts to input into the generative AI model. For example, a recipe is generated based on a prompt such as "User ID: 123, Favorite ingredients: Chicken, Avoided ingredients: Onion, Nut allergy, Low calorie." Input: Analyzed preferences and restriction information. Output: Generated customized recipe.

[0708] Step 5:

[0709] The server uses natural language generation AI to describe the generated recipe in detail and sends it to the device. The server then describes each step of the generated recipe, the list of ingredients, the time required, and important points in natural language in detail and sends it to the user's device. For example, a "low-calorie recipe using chicken and tomatoes" is sent along with detailed instructions. Input: The generated customized recipe. Output: A detailed recipe document sent to the user's device.

[0710] Step 6:

[0711] The device displays the generated recipe. The recipe sent to the user's device is displayed through the application. The user checks the recipe, prepares the necessary ingredients, and starts cooking. For example, "Low-calorie dish using chicken and tomatoes" is displayed. Input: Detailed recipe sent from the server. Output: Recipe displayed on the device.

[0712] Step 7:

[0713] The server searches for suppliers that offer the proposed dishes based on the generated recipe and suggests them to the terminal. The server searches a database of restaurants and delivery services to suggest suppliers that offer dishes that match the user's preferences and restrictions. For example, it may suggest to the user information such as "nearby Restaurant A offers this dish." Input: Generated recipe and supplier database. Output: Supplier suggestion information.

[0714] Step 8:

[0715] The user places an order directly from the suggested supplier. The user orders food directly from the suggested restaurant or delivery service through the application. For example, a user can "order a low-calorie menu item with chicken and tomatoes from Restaurant A." Input: Supplier information. Output: Order confirmation information.

[0716] Step 9:

[0717] The user inputs feedback about the recipe into the terminal and sends it to the server. After cooking or ordering, the user inputs their opinions and thoughts about the recipe and sends it to the server via the terminal. For example, feedback such as "It was delicious, but I wish it was a little more spiced" is input. Input: User feedback information. Output: Feedback sent to the server.

[0718] Step 10:

[0719] The server stores the received feedback in a database and analyzes it using a machine learning algorithm (e.g., TensorFlow). The server stores the feedback data in a database and analyzes it using a machine learning algorithm to optimize the recipe generation algorithm for future uses. Input: Feedback information sent by the user. Output: Analyzed feedback and optimized recipe generation algorithm.

[0720] Step 11:

[0721] The next recipe is generated based on the optimized recipe generation algorithm and provided to the user. The server uses the optimized recipe generation algorithm based on the feedback to generate subsequent recipes and provide more personalized suggestions to the user. Input: Optimized recipe generation algorithm. Output: Next customized recipe.

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

[0723] The present invention combines a system that provides original recipes based on a user's preferences, dietary restrictions, allergy information, and dietary history with an emotion engine that recognizes the user's emotions. By taking the user's emotional state into account, the system can provide more personalized recipes.

[0724] System Overview

[0725] The system consists of a device used by the user, a server that supports it, and an emotion engine. Users input profile information such as preferences, dietary restrictions, allergies, and dietary history through their device. At the same time, the emotion engine recognizes the user's emotions and collects that information. This information is sent to the server, which generates recipes based on that information and also receives feedback and makes improvements.

[0726] Program processing

[0727] User: The user first launches the application and logs in. They enter profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I prefer a low-calorie diet." The application also reads the user's emotions through facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[0728] Device: The entered profile information and emotion information is sent to the server using a common data format such as JSON.

[0729] Server: Stores the received profile information and emotion information in a database. A unique ID is assigned to each user, and the profile information and emotion information are classified and organized.

[0730] Server: Analyzes profile information and emotional information using a natural language processing module and emotion engine. From the information, the server identifies the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[0731] Server: Runs a recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe." The recipe's difficulty, time required, and availability of ingredients are also taken into account.

[0732] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[0733] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[0734] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[0735] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[0736] Terminal: After cooking, a rating form is displayed to the user. A star rating (1 to 5 stars) and a comment input field are provided. The user's feelings after cooking are also collected again.

[0737] User: Enter feedback about the cooking. For example, enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send another emotional response.

[0738] Terminal: Sends the input feedback and emotion information to the server. Feedback data is also sent in JSON format.

[0739] Server: Stores the received feedback and emotional information in a database and analyzes it. It identifies common comments and evaluation points based on the feedback content and emotional information.

[0740] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[0741] In this way, the present invention provides customized recipes based on a user's preferences, dietary restrictions, allergy information, and even emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

[0742] The processing flow will be explained below.

[0743] Step 1:

[0744] User: Launches the application and logs in. Enters profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I would like a low-calorie diet." At the same time, the emotion engine obtains the user's emotions through facial recognition and voice analysis, and acquires emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[0745] Step 2:

[0746] Device: The entered profile information and emotion information is sent to the server using a common data format such as JSON.

[0747] Step 3:

[0748] Server: Stores the received profile information and emotion information in a database. A unique ID is assigned to each user, and the profile information and emotion information are classified and organized.

[0749] Step 4:

[0750] Server: Analyzes profile information and emotional information using a natural language processing module and emotion engine. From the information, the server identifies the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[0751] Step 5:

[0752] Server: Runs a recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe." The recipe's difficulty, time required, and availability of ingredients are also taken into account.

[0753] Step 6:

[0754] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[0755] Step 7:

[0756] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[0757] Step 8:

[0758] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[0759] Step 9:

[0760] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[0761] Step 10:

[0762] Terminal: After cooking, a rating form is displayed to the user. A star rating (1 to 5 stars) and a comment input field are provided. The user's feelings after cooking are also collected again.

[0763] Step 11:

[0764] User: Enter feedback about the cooking. For example, enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send another emotional response.

[0765] Step 12:

[0766] Terminal: Sends the input feedback and emotion information to the server. Feedback data is also sent in JSON format.

[0767] Step 13:

[0768] Server: Stores the received feedback and emotional information in a database and analyzes it. It identifies common comments and evaluation points based on the feedback content and emotional information.

[0769] Step 14:

[0770] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[0771] In this way, the present invention provides customized recipes based on a user's preferences, dietary restrictions, allergy information, and even emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

[0772] Example 2

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

[0774] Conventional recipe provision systems were able to provide personalized recipes based on a user's preferences, dietary restrictions, allergy information, and dietary history, but they did not take into account the user's emotional state, making it difficult to provide recipes that were truly suited to each individual user. In particular, they were unable to take into account the fact that a user's mood and emotional state have a significant impact on appetite and ingredient selection, which limited the improvement of the user experience. In addition, the system was not sufficiently optimized through feedback analysis, and there was a lack of means to improve the system's accuracy.

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

[0776] In this invention, the server includes a means for storing received user information and emotional information in a database, a means for analyzing the user information and emotional information using a natural language processing module and an emotion engine, and a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user. This enables the provision of more personalized recipes that take into account the user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. Furthermore, by analyzing the received feedback and emotional information using a machine learning algorithm and reflecting this in the next recipe generation, the system can be continuously optimized and the user experience can be improved.

[0777] "User information" refers to personal profile information such as the user's preferences, dietary restrictions, allergy information, and dietary history.

[0778] "Emotion information" is information that indicates the user's mood or emotional state, such as whether the user is feeling stressed or relaxed.

[0779] A "server" is a computer system that receives, stores, analyzes user information and emotion information, and generates recipes.

[0780] A "natural language processing module" is a software module that analyzes input user information and extracts meaning from it.

[0781] An "emotion engine" is an algorithm or software that analyzes a user's facial recognition and voice data to identify the user's emotional state.

[0782] The "recipe generation algorithm" is an algorithm for generating an optimal recipe based on analyzed user information and emotional information.

[0783] A "natural language generation model" is an AI model that generates analysis results and recipes for users in natural-sounding sentences.

[0784] "Feedback" refers to response information such as user ratings and comments on the provided recipe.

[0785] "Machine learning algorithms" are algorithms used to optimize the performance of the system based on the feedback and sentiment information received.

[0786] This system provides original recipes by combining a user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. This system consists of a terminal used by the user, a server that supports it, and an emotion engine.

[0787] Hardware and software used

[0788] To realize this system, the following hardware and software are used:

[0789] Device: User device such as smartphone, tablet, or PC

[0790] Server: Cloud server or on-premise server

[0791] Database: Relational database such as MySQL or PostgreSQL

[0792] Natural language processing modules: Libraries such as SpaCy and NLTK

[0793] Emotion engine: facial recognition software, voice analysis tools

[0794] Recipe generation algorithms: Python scripts, algorithm libraries

[0795] Natural language generation models: AI models such as GPT-4

[0796] Machine learning algorithms: Libraries such as Scikit-Learn and TensorFlow

[0797] Program processing and specific examples

[0798] User: The user first launches the application and logs in. They enter profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I'd like a low-calorie diet." The application also reads the user's emotions through facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[0799] Device: The device sends the entered profile information and emotion information to the server. The data is sent in a common data format such as JSON.

[0800] Server: The server stores the received profile information and emotion information in a database. It assigns a unique ID to each user and organizes the profile information and emotion information.

[0801] Server: The profile information and sentiment information are then analyzed by a natural language processing module and sentiment engine, which identifies the user's preferences, allergies, dietary restrictions, and emotional state.

[0802] Server: Runs the recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[0803] Server: The selected recipes are converted into text using natural language generation AI (e.g., GPT-4), which then details the recipe steps, ingredient list, cooking time, and precautions.

[0804] Server: Sends the generated recipe data to the user's device.

[0805] Device: The device displays the submitted recipe in a visually friendly format, including the recipe title, ingredients list, cooking steps, cooking time, difficulty level, etc.

[0806] User: The user prepares ingredients based on the displayed recipe and begins cooking. While cooking, the user continues to follow the instructions while referring to the device.

[0807] Terminal: After cooking, the terminal displays a rating form to the user, providing a star rating (1-5 stars) and a comment input field, and also collecting emotional information.

[0808] User: Enter feedback. Example: Enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send emotional information again.

[0809] Device: Sends rating and emotion information to the server. Feedback data is also sent in JSON format.

[0810] Server: The received feedback and emotional information are stored in a database and analyzed. Common comments and evaluation points are identified based on the feedback content and emotional information.

[0811] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback information and sentiment information. This information is reflected in future recipe suggestions.

[0812] Prompt Sentence Examples

[0813] As a concrete example, consider a case where a user wants a recipe that is low in calories and has a stress-relieving effect. Here is an example prompt to input to the generative AI model:

[0814] User Preference Profile:

[0815] Favorite ingredients: chicken, tomatoes

[0816] Disliked food: Onions

[0817] Allergens: nuts

[0818] Dietary restrictions: Low calorie

[0819] Emotional state: Stressed

[0820] Please suggest a recipe that meets these criteria, including a specific ingredient list, cooking instructions, cooking time, and any warnings.

[0821] In this way, the system can provide customized recipes based on the user's preferences, dietary restrictions, allergy information, and even emotional state, and use that feedback to improve the system's accuracy.

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

[0823] Step 1:

[0824] User: A user launches an application and logs in.

[0825] Input: User ID, Password

[0826] Output: Login success or failure message

[0827] Specific operation: The user starts the application and enters their user ID and password on the login screen. When they press the "Login" button, the device sends the entered information to the server. The server compares it with the user information database and returns a message to the device indicating whether the login was successful. If a success message is displayed, the user can proceed to the next step.

[0828] Step 2:

[0829] User: Enters preferences, dietary restrictions, allergy information, past dietary history, and emotional state.

[0830] Input: food preferences, dietary restrictions, allergy information, past dietary information, emotional information

[0831] Output: Confirmation message for input contents

[0832] How it works: Users fill out a form in the application to enter their preferences, dietary restrictions, allergies, and dietary history, and provide their emotional state using facial recognition and voice input. When they press the "Send" button, the device sends this information to the server in JSON format.

[0833] Step 3:

[0834] Terminal: Sends the entered profile information and emotion information to the server.

[0835] Input: JSON format profile information, emotion information

[0836] Output: Message indicating that the data sent to the server has been sent successfully

[0837] Specific operation: JSON data containing profile information and emotion information is sent to the server via HTTPS. After sending, the device displays a message to the user indicating completion of sending.

[0838] Step 4:

[0839] Server: Stores the received data in a database.

[0840] Input: JSON format profile information, emotion information

[0841] Output: Database update completion message

[0842] Specific operation: The server parses the received JSON data and stores it in a relational database such as MySQL or PostgreSQL. A unique ID is assigned to each user data item and the data is properly organized. A completion message is generated when the database update is complete.

[0843] Step 5:

[0844] Server: Analyzes user information and emotional information using a natural language processing module and emotion engine.

[0845] Input: Profile information and emotion information stored in the database

[0846] Output: Analysis results (user preferences, allergies, dietary restrictions, emotional state)

[0847] How it works: Using natural language processing modules (e.g., SpaCy or NLTK) and emotion engines (facial recognition software, speech analysis tools), the system analyzes profile information and emotional information. The results of the analysis are used to identify and extract new user preferences, allergies, dietary restrictions, and emotional state, and store them in a database.

[0848] Step 6:

[0849] Server: Executes the recipe generation algorithm based on the analysis results.

[0850] Input: Analysis results (user preferences, allergies, dietary restrictions, emotional state)

[0851] Output: Generated recipe information

[0852] How it works: Using a recipe generation algorithm (Python script or algorithm library), the system searches the database for the best recipe based on the analysis results and generates a customized recipe for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[0853] Step 7:

[0854] Server: Uses natural language generation AI to write down the details of the generated recipe.

[0855] Input: Generated recipe information

[0856] Output: Written recipe details

[0857] What it does: It uses a natural language generation model (e.g., GPT-4) to generate natural-sounding details for the generated recipe, including information like ingredient lists, cooking instructions, cooking times, and warnings.

[0858] Step 8:

[0859] Server: Sends the generated recipe data to the user's device.

[0860] Input: Written recipe details

[0861] Output: A message to the terminal indicating that transmission is complete

[0862] Specific operation: The generated recipe data is converted to JSON format and sent to the user's device. A transmission completion message is generated on the server side.

[0863] Step 9:

[0864] Terminal: Displays submitted recipes in a visually friendly format.

[0865] Input: Recipe data in JSON format

[0866] Output: Recipe display screen

[0867] Specific operation: The device parses the JSON format recipe data received and displays the recipe information visually in an easy-to-understand manner on a GUI (Graphical User Interface). This is implemented using libraries such as Vue.js and React.

[0868] Step 10:

[0869] User: Prepare ingredients and start cooking.

[0870] Input: Recipe details

[0871] Output: Finished dish

[0872] Specific operation: The user gathers the necessary ingredients based on the displayed recipe and begins cooking according to the instructions. During cooking, the user refers to the device screen for each step and uses the "Next" button to proceed through the steps.

[0873] Step 11:

[0874] Terminal: Display the evaluation form after cooking.

[0875] Input: None (cooking completion trigger)

[0876] Output:Evaluation form display

[0877] Specific operation: Once cooking is complete, the device will automatically display a rating form in a pop-up window, etc. The rating form includes a star rating (1-5 stars) and a comment input field, as well as an option to obtain additional emotional information.

[0878] Step 12:

[0879] Users: Enter your rating and feedback.

[0880] Input: Rating (star rating and comments), sentiment information

[0881] Output: Sending rating and sentiment data

[0882] Specific operation: The user enters a star rating and a comment in the rating form, and then presses the "Submit" button to send the feedback and emotional information. The content is sent from the device to the server in JSON format.

[0883] Step 13:

[0884] Terminal: Sends ratings and emotion information to the server.

[0885] Input: Evaluation information, emotion information

[0886] Output: Message sent to server

[0887] Specific operation: The input rating and emotion information is converted into JSON format and sent to the server using the HTTPS protocol. After the transmission is complete, the device displays a completion message.

[0888] Step 14:

[0889] Server: Stores the received ratings and emotion information in a database and performs analysis.

[0890] Input: Feedback and sentiment information in JSON format

[0891] Output: Analysis complete message

[0892] Specific operation: The received feedback and emotional information are stored in a database, and analyzed using the analysis module. Common comments and evaluation points are identified from the feedback content and emotional information, and the analysis results are stored in the database.

[0893] Step 15:

[0894] Server: Optimizes the recipe generation algorithm using machine learning algorithms.

[0895] Input: Analysis results, feedback information, emotion information

[0896] Output: Optimized recipe generation algorithm

[0897] How it works: Using machine learning algorithms (e.g., Scikit-Learn or TensorFlow), the recipe generation algorithm is optimized based on the analysis results, feedback, and sentiment information. Once the optimization is complete, the algorithm is reflected in the next recipe generation.

[0898] (Application example 2)

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

[0900] Conventional recipe suggestion systems generate recipes based only on the user's preferences, dietary restrictions, allergy information, and dietary history, resulting in insufficient personalization based on the user's emotional state. Furthermore, there are limitations to their application in brick-and-mortar establishments such as restaurants, and challenges remain in improving motivation and satisfaction in line with the user's emotions. In particular, there is a need for systems that can provide optimal meal menus tailored to the customer's emotional state.

[0901] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for inputting a user's preferences, dietary restrictions, allergy information, and dietary history; means for transmitting the input information to the server; means for storing the received user information in a database; means for analyzing the user information using a natural language processing module; means for executing a recipe generation algorithm based on the analysis results and generating a recipe optimal for the user; means for transmitting the generated recipe to the user's terminal; means for displaying the transmitted recipe on the user's terminal; means for transmitting user feedback to the server; means for storing and analyzing the received feedback in a database; means for optimizing the recipe generation algorithm based on the analysis results; an emotion recognition engine for recognizing the user's emotional state; means for transmitting the recognized emotion information to the server; and means for generating a recipe appropriate for the user's emotional state based on the emotion information and profile information. This enables personalized recipe suggestions based on the user's emotional state, thereby improving customer satisfaction even in physical stores.

[0902] "User preferences" refers to the user's preferred foods, ingredients, seasoning preferences, etc.

[0903] "Dietary Restrictions" refers to restrictions on foods or nutrients that a user should avoid for health reasons or personal preferences.

[0904] "Allergy information" is information about foods and ingredients that may cause a user an allergic reaction.

[0905] "Dietary history" is information about the contents of meals the user has eaten in the past and their history.

[0906] An "emotion recognition engine" is a system that recognizes a user's emotional state from their facial expressions, voice, etc., and converts it into digital data.

[0907] "Profile information" is comprehensive personal information such as the user's preferences, dietary restrictions, allergy information, and dietary history.

[0908] A "natural language processing module" refers to a program or algorithm that analyzes input text information and understands its meaning.

[0909] A "recipe generation algorithm" is a calculation method for generating an optimal recipe based on a user's profile information.

[0910] "Feedback" refers to ratings and comments that users make about recipes and services provided.

[0911] A "machine learning algorithm" is an algorithm that improves system performance based on feedback and usage history.

[0912] The "database" is a system for efficiently managing and storing user information, profile information, generated recipes, feedback, etc.

[0913] This invention relates to a system that provides optimal recipes based on a user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. This system is composed of a terminal used by the user, a server, and an emotion recognition engine.

[0914] First, the user launches the application on a device such as a smartphone or tablet and logs in. After that, the user enters their preferences, dietary restrictions, allergy information, and dietary history. An emotion recognition engine then recognizes emotions from the user's face and voice, and this information is also acquired. This information is then sent from the device to the server in JSON format or similar.

[0915] The information received by the server is stored in a database, where it is categorized and organized by assigning a unique ID to each user. The server then uses a natural language processing module and an emotion recognition engine to analyze the user's profile information and emotional information. Based on the analysis results, a recipe generation algorithm is executed to search for and customize the optimal recipe. For example, a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe" is generated. The recipe's difficulty, required time, and ease of obtaining ingredients are also taken into consideration.

[0916] The generated recipe is then written in detail using natural language generation AI, including specific recipe steps, ingredient lists, cooking times, and important notes. This information is then sent back to the device in JSON format, where users can view it in a visually easy-to-understand format.

[0917] The user creates a dish based on the recipe and is presented with a feedback form to rate the results. A star rating (1-5 stars) and a comment input field are provided, and emotional information after cooking is also collected. This feedback and emotional information is again sent from the device to the server. The server stores the received feedback in a database and analyzes it. Based on the results of this analysis, a machine learning algorithm optimizes the recipe generation algorithm and reflects it in future recipe suggestions.

[0918] For example, if a user's profile information is "Favorite ingredients are chicken and tomatoes, least favorite ingredients are onions, allergies are nuts, and a low-calorie diet is desired," and the emotion recognition engine recognizes that the user is "feeling good today," it will suggest a "low-calorie chicken and tomato recipe."An example of a prompt sentence is as follows:

[0919] Example prompt sentence:

[0920] User profile: Favorite foods are chicken and tomatoes, dislikes onions, allergies to nuts. Prefers low-calorie meals.

[0921] Today's feeling: I feel good.

[0922] Generate optimal recipes based on this profile and sentiment.

[0923] In this way, the present invention provides recipes customized based on the user's preferences, dietary restrictions, allergy information, and emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

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

[0925] Step 1:

[0926] The user launches the application on their device and logs in. The user enters their preferences, dietary restrictions, allergy information, and dietary history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I prefer a low-calorie diet." The input data is converted to JSON format.

[0927] Input: User preferences, dietary restrictions, allergy information, dietary history

[0928] Output: Profile information in JSON format

[0929] Step 2:

[0930] The emotion recognition engine reads the user's emotions from facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[0931] Input: User's facial image or voice data

[0932] Output: Emotional information

[0933] Step 3:

[0934] The device sends profile information (step 1) and emotion information (step 2) to the server. The data is sent in JSON format.

[0935] Input: JSON format profile information, emotion information

[0936] Output: Send data to the server

[0937] Step 4:

[0938] The server stores the received profile information and emotion information in a database. Each user is assigned a unique ID and classified and organized.

[0939] Input: JSON format profile information, emotion information

[0940] Output: Store in database

[0941] Step 5:

[0942] The server analyzes the received data using a natural language processing module and an emotion recognition engine, thereby identifying the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[0943] Input: Profile information and emotion information stored in the database

[0944] Output: Analysis results (user preferences, allergy information, dietary restrictions, emotional state)

[0945] Step 6:

[0946] The server runs a recipe generation algorithm based on the analysis results, searching for suitable recipes from a database and customizing them for the user. For example, it generates a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[0947] Input: Analysis results

[0948] Output: Customized recipe data

[0949] Step 7:

[0950] The server uses natural language generation AI to translate the details of the generated recipe into text, including recipe steps, ingredient list, cooking time, and important notes.

[0951] Input: Customized recipe data

[0952] Output: A written recipe

[0953] Step 8:

[0954] The server sends the generated recipe to the user's terminal, and sends the recipe data in response to the request.

[0955] Input: Written recipe

[0956] Output: Send recipe to terminal

[0957] Step 9:

[0958] The device displays the recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty level, and other information in a visually easy-to-understand format.

[0959] Input: Data to send to the terminal

[0960] Output: A visual representation of the recipe

[0961] Step 10:

[0962] The user checks the displayed recipe, prepares the necessary ingredients, and begins cooking. While cooking, the user continues to follow the instructions while referring to the device.

[0963] Input: Display recipe to user

[0964] Output: User cooking action

[0965] Step 11:

[0966] After cooking, the device displays a rating form to the user, providing a star rating (1 to 5 stars) and a comment input field. The device also collects the user's feelings after cooking.

[0967] Input: User operation after recipe cooking

[0968] Output: Evaluation form, retrieved emotional information

[0969] Step 12:

[0970] The user enters feedback about the cooking, for example, "4 stars, it was delicious but I'd like to add a little spice," and also submits emotional information.

[0971] Input: Evaluation form, comments, sentiment information

[0972] Output: Feedback data

[0973] Step 13:

[0974] The device sends the input feedback and emotion information to the server, and the data is again sent in JSON format.

[0975] Input: Feedback data

[0976] Output: Send data to the server

[0977] Step 14:

[0978] The server stores the received feedback and emotional information in a database and analyzes it. It identifies frequently occurring comments and evaluation points based on the feedback content and emotional information.

[0979] Input: Feedback data, emotional information

[0980] Output: Parsed data

[0981] Step 15:

[0982] The server uses a machine learning algorithm to optimize the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[0983] Input: Parsed data

[0984] Output: Optimized recipe generation algorithm

[0985] Through these processing steps, the present invention is able to provide and continually improve personalized recipes that take into account a user's preferences, dietary restrictions, allergy information, and emotional state.

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

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

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

[0989] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1002] The present invention is a system that provides original recipes that take into account the user's preferences, dietary restrictions, allergy information, and dietary history. This system mainly involves a process in which the user inputs information through a terminal, the server generates recipes based on that information, and then receives feedback and makes improvements.

[1003] System Overview

[1004] The system consists of a device used by the user and a server that supports it. Users enter profile information such as preferences, dietary restrictions, allergies, and dietary history through their own device. This information is sent to the server, which stores it in a database. Here, a natural language processing module analyzes the user information and runs a recipe generation algorithm to generate the optimal recipe for the user.

[1005] Program processing

[1006] User: The user first launches the application and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, they can enter chicken as their favorite food, onions as their least favorite food, nuts as their allergic food, and request a low-calorie diet.

[1007] Terminal: The entered information is sent from the user's terminal to the server. The terminal sends this information in the appropriate format so that the server can receive it.

[1008] Server: The server stores the received information in a database, which stores each user's profile information. A natural language processing module then analyzes the stored information to identify the user's preferences and restrictions.

[1009] Server: The recipe generation algorithm is executed based on the analysis results. The algorithm searches the database for relevant recipes and customizes them to suit the user's preferences and restrictions. For example, a "low-calorie recipe using chicken and tomatoes" may be generated. The algorithm also takes into account the difficulty of the recipe, the time required, and the difficulty of obtaining ingredients, so recipes that are easy for beginners to follow are provided.

[1010] Server: The generated recipe is described in detail by natural language generation AI and sent to the user's device.

[1011] Device: The generated recipe is displayed on the user's device. The user checks the recipe, prepares the necessary ingredients, and starts cooking. The recipe includes cooking instructions, a list of ingredients, cooking time, and important notes.

[1012] User: After cooking is complete, the user can provide feedback on the recipe. For example, they can comment, "It was delicious, but I wish it had a few more spices."

[1013] Terminal: The feedback information is sent back to the server, which stores it in a database.

[1014] Server: The received feedback is analyzed using a machine learning algorithm. The recipe generation algorithm is adjusted based on the feedback and reflected in future recipe generation. This allows the system to provide recipes that are more tailored to the user's preferences.

[1015] In this way, the present invention is a system that can generate and provide optimal original recipes taking into account the user's preferences, dietary restrictions, and allergy information. Furthermore, it is possible to continuously improve the recipe generation algorithm based on user feedback, realizing an optimal diet for each individual user.

[1016] The processing flow will be explained below.

[1017] Step 1:

[1018] User: Launches the application and logs in. Enters profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite foods are chicken and tomatoes, my least favorite foods are onions, I'm allergic to nuts, and I prefer a low-calorie diet."

[1019] Step 2:

[1020] Device: The entered profile information is sent to the server using a common data format such as JSON.

[1021] Step 3:

[1022] Server: Stores the received profile information in a database. A unique ID is assigned to each user, and the profile information is categorized and organized.

[1023] Step 4:

[1024] Server: Analyzes profile information using a natural language processing module, identifies user preferences, allergies, and dietary restrictions from the information, and extracts analysis results.

[1025] Step 5:

[1026] Server: Runs the recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. This takes into account the difficulty of the recipe, the time required, and the ease of obtaining ingredients. For example, it selects a "low-calorie recipe with chicken and tomatoes."

[1027] Step 6:

[1028] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[1029] Step 7:

[1030] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[1031] Step 8:

[1032] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[1033] Step 9:

[1034] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[1035] Step 10:

[1036] Terminal: After cooking, a rating form is displayed to the user, providing a star rating (1 to 5 stars) and a comment input field.

[1037] Step 11:

[1038] User: Enter feedback about the cooking. For example, enter a comment like "4 stars, it was delicious but I'd like it to be a little spiced up."

[1039] Step 12:

[1040] Terminal: Sends the entered feedback to the server. Feedback data is also sent in JSON format.

[1041] Step 13:

[1042] Server: Stores the received feedback in a database and analyzes it. It identifies common comments and evaluation points from the feedback.

[1043] Step 14:

[1044] Server: The machine learning algorithm optimizes the recipe generation algorithm based on the feedback information. The feedback is used as learning data to be reflected in future recipe generation.

[1045] In this way, the present invention provides recipes that are customized based on a user's preferences, dietary restrictions, and allergy information, and can continuously improve their accuracy based on user feedback.

[1046] Example 1

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

[1048] Conventional recipe provision systems have had the problem of being unable to provide original recipes that fully take into account the user's preferences, dietary restrictions, allergy information, and dietary history. Furthermore, there were few systems that could efficiently analyze user feedback and reflect it in the next recipe generation. This made it difficult to provide recipes that were suited to each individual user, and there was a need to improve user satisfaction.

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

[1050] In this invention, the server includes a means for storing received user information in a database, a means for analyzing the user information using a natural language processing module, a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user, and a means for describing the generated recipe in detail using a natural language generation model and transmitting the description to the user's terminal. This makes it possible to provide optimal recipes that take into account the user's individual preferences and dietary restrictions. In addition, user feedback can be analyzed using a machine learning algorithm and reflected in the next recipe generation, enabling continuous system optimization.

[1051] "User" refers to a person who uses a terminal to input information such as preferences, dietary restrictions, allergy information, and dietary history, and receives the optimal recipe from the system.

[1052] "Preferences" is information that indicates the specific ingredients or types of dishes that a user likes.

[1053] "Dietary Restrictions" refers to information about specific ingredients or foodstuffs that a user should avoid consuming.

[1054] "Allergy information" is information about specific ingredients to which a user may have an allergic reaction.

[1055] "Dietary history" is information about a record of meals the user has taken in the past and their evaluations.

[1056] "Terminal" refers to the hardware device through which a user inputs information and checks recipes, such as a smartphone, tablet, or PC.

[1057] A "server" is a computer system that receives information sent by users, stores it in a database, and performs analysis and recipe generation.

[1058] A "database" is a digital storage system for storing user information, generated recipes, feedback information, and the like.

[1059] A "natural language processing module" is a software module for analyzing received user information and understanding text data.

[1060] A "recipe generation algorithm" is a series of calculations used to generate optimal recipes based on a user's preferences, dietary restrictions, etc.

[1061] A "natural language generation model" is an AI technology that describes the generated recipe in detail and provides it to the user in natural language.

[1062] "Feedback" refers to comments that users can send to the system, such as their thoughts, ratings, and suggestions for improvement regarding the provided recipe.

[1063] A "machine learning algorithm" is a learning method that analyzes user feedback and reflects it in the next recipe generation.

[1064] The present invention is a system that provides original recipes that take into account the user's preferences, dietary restrictions, allergy information, and dietary history. This system involves a process in which the user inputs information through a terminal, the server generates recipes based on that information, and the system receives feedback and makes improvements.

[1065] Hardware and software used

[1066] Device: The device used by the user, such as a smartphone, tablet, or PC (e.g., iOS, Android, Windows, macOS).

[1067] Server: Cloud server (e.g. AWS, Google Cloud, Microsoft Azure).

[1068] software:

[1069] Natural language processing modules (e.g. spaCy, NLTK).

[1070] Recipe generation algorithms (custom algorithms, machine learning models).

[1071] Database (e.g. MySQL, PostgreSQL).

[1072] Natural language generation AI (e.g. GPT-3, ChatGPT).

[1073] Program Processing Details

[1074] User: First, the user launches a dedicated application on their device and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, the user might fill in the input form with "Favorite food: chicken," "Disliked food: onion," "Allergy: nuts," "Desired: low calorie," etc.

[1075] Terminal: The terminal encrypts the information entered by the user using HTTPS and sends it to the server via a REST API. The terminal converts the information into JSON format and sends a request to the appropriate API endpoint.

[1076] Server: The server analyzes the received information and stores it in a database. The database stores each user's profile information. The server then analyzes the user information using a natural language processing module (e.g., spaCy), tokenizing the text data and identifying keywords such as "favorite ingredients" or "allergies." It then identifies the user's preferences and restrictions and prepares the analysis results.

[1077] Server: Runs a recipe generation algorithm based on the analysis results. This algorithm searches the database for suitable recipes. For example, it prioritizes recipes that use "chicken and tomato" or low-calorie recipes. The generated recipe is then written in detailed text using natural language generation AI (e.g., GPT-3). The generation AI generates the recipe name "Low-calorie chicken and tomato salad," along with cooking instructions, ingredient list, required time, and precautions.

[1078] Server: The generated recipe is sent to the user's device via the REST API in JSON format.

[1079] Device: The user's device receives the data from the server and displays the recipe on the app's UI. The user can check this information, prepare the necessary ingredients, and start cooking.

[1080] User: After cooking is complete, the user can enter feedback about the recipe through the application. For example, they can comment in the text box, "It was delicious, but I would like it to be a little more spiced."

[1081] Terminal: The feedback information entered by the user is again sent from the terminal to the server. This process is also encrypted using HTTPS and sent via the REST API, just like the information sending step.

[1082] Server: The received feedback is analyzed by a machine learning algorithm. The server analyzes the feedback using a natural language processing module and classifies the feedback content by element. For example, it extracts positive comments such as "delicious" and "I'd like to add some spices" as well as requests for improvement. The recipe generation algorithm is adjusted based on the analysis results. The feedback content is added as a new data point to the algorithm's training data, and the model is retrained, so that it is reflected in future recipe generation.

[1083] Examples of concrete examples and prompts

[1084] Examples:

[1085] User: "I like chicken, hate onions, and I'm allergic to nuts. I'd also like to eat a low-calorie diet."

[1086] Recipe generated from the server: "Low-calorie salad with chicken and tomatoes. Cooking instructions: 1. Boil the chicken. 2. Chop the tomatoes. 3. Mix the chicken and tomatoes and toss with olive oil."

[1087] Example prompt for generative AI model:

[1088] User Information:

[1089] Favorite food: Chicken

[1090] Disliked food: Onions

[1091] Allergies: Nuts

[1092] Desired: Low calorie

[1093] Use this information to generate low-calorie recipes tailored to your users.

[1094] In this way, the present invention creates a system that can generate and provide optimal original recipes taking into account the user's preferences, dietary restrictions, and allergy information. Furthermore, it is possible to continuously improve the recipe generation algorithm based on user feedback, realizing an optimized diet for each individual user.

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

[1096] Step 1:

[1097] Information input step

[1098] User: First, the user launches a dedicated application on their device and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, the user might fill in the input form with "Favorite food: chicken," "Disliked food: onion," "Allergy: nuts," "Want: low calories," etc. This information becomes data used to communicate the user's individual preferences and restrictions to the system.

[1099] Step 2:

[1100] Information transmission steps

[1101] Terminal: The terminal encrypts the information entered by the user using HTTPS and sends it to the server via the REST API. The terminal converts the information into JSON format and sends a request to the appropriate API endpoint. The input data (preferences, allergy information, dietary restrictions, dietary history) is encrypted and sent to the server.

[1102] Step 3:

[1103] Information storage step

[1104] Server: The server parses the received information and stores it in a database. This information includes the user's preferences, allergy information, dietary restrictions, and past dietary history. The database stores profile information for each user. The received input data is parsed and inserted into the "users" table using a database manipulation library (e.g., SQLAlchemy).

[1105] Step 4:

[1106] Information Analysis Step

[1107] Server: The server uses a natural language processing module (e.g., spaCy) to analyze user information. For example, it tokenizes text data and identifies keywords such as "favorite ingredients" and "allergies." As a result, the user's preferences and restrictions become clear. The input data is user information (preferences, allergy information, dietary restrictions), and this data is analyzed to output results such as "favorite ingredients: chicken" and "allergies: nuts."

[1108] Step 5:

[1109] Recipe Generation Steps

[1110] Server: Runs a recipe generation algorithm based on the analysis results. This algorithm searches the database for suitable recipes and customizes them to fit the user's preferences and restrictions. For example, it may prioritize recipes using "chicken and tomatoes" or low-calorie recipes. The analysis results are provided as input data, and a customized recipe is output based on them.

[1111] Step 6:

[1112] Recipe Description Steps

[1113] Server: The generated recipe is described in detail as text using natural language generation AI (e.g., GPT-3). The generation AI creates information such as the recipe name "Low-calorie chicken and tomato salad," cooking instructions, ingredient list, required time, and precautions. The input data is the analysis results and the generated recipe, and a detailed recipe is output based on this.

[1114] Step 7:

[1115] Recipe Send and View Steps

[1116] Server: The generated recipe is sent to the user's device. This is also sent in JSON format via the REST API. The generated recipe data is entered and converted into the format to be sent.

[1117] Device: The user's device receives the data from the server and displays it on the app's UI. The user can check the recipe details and start cooking through this UI. The received JSON data is converted into a format that is displayed in the UI.

[1118] Step 8:

[1119] Feedback Input Step

[1120] User: After cooking is complete, the user enters feedback about the recipe through the application. For example, they might comment in a text box, "It was delicious, but I'd like it to have a bit more spice." This feedback information becomes data to improve the recipe generation for future recipes.

[1121] Step 9:

[1122] Feedback submission step

[1123] Terminal: The feedback information entered by the user is again sent from the terminal to the server. This process, like the information sending step, is encrypted using HTTPS and sent via the REST API. The input data is the user's feedback content, which is encrypted and sent to the server.

[1124] Step 10:

[1125] Feedback Analysis Step

[1126] Server: The received feedback is analyzed using a machine learning algorithm. The server analyzes the feedback using a natural language processing module and classifies the feedback content by element. For example, it extracts positive comments such as "delicious" and "I'd like to add some spice" as well as requests for improvement. The feedback data is input and the content is output by category.

[1127] Step 11:

[1128] Algorithm Adjustment Steps

[1129] Server: Adjusts the recipe generation algorithm based on the analysis results. The feedback content is added as a new data point to the algorithm's training data, and the model is retrained. This is reflected in future recipe generation. The feedback analysis results are input, and an optimized algorithm is output.

[1130] Step 12:

[1131] Optimized recipe provision steps

[1132] Server: Based on user feedback, the algorithm is adjusted so that future recipes are more tailored to the individual user. This allows the user to receive recipes that are increasingly tailored to them. Using the optimized algorithm, new recipes are generated and output.

[1133] (Application example 1)

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

[1135] Many modern food delivery services offer a standard menu without adequately considering individual requirements such as user preferences, dietary restrictions, and allergy information. This makes it difficult for users to choose the right dish, and they may suggest dishes that do not accommodate allergies or dietary restrictions. This results in lower user satisfaction and a decrease in the frequency of use of food delivery services. Furthermore, the lack of a mechanism for incorporating feedback after an order to improve suggestions for the next order slows down the improvement of the user experience.

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

[1137] In this invention, the server includes means for inputting a user's preferences, dietary restrictions, allergy information, and dietary history, means for transmitting the input information to the server, and means for storing the received user information in a database. This enables the generation of optimal recipes that take into account the user's individual requirements. The server further includes means for analyzing the user information using a natural language processing module, means for executing a recipe generation algorithm based on the analysis results to generate an optimal recipe for the user, means for transmitting the generated recipe to the user's terminal, means for displaying the transmitted recipe on the user's terminal, and means for transmitting feedback from the user to the server. The server also includes means for storing and analyzing the received feedback in a database, means for optimizing the recipe generation algorithm based on the analysis results, means for searching for and suggesting suppliers that provide suggested dishes based on the generated recipe, and means for directly ordering from the suggested suppliers. This allows users to easily order dishes that suit their preferences and dietary restrictions, and the next suggestions are further optimized based on the feedback, significantly improving the user experience.

[1138] "User preferences" refer to the characteristics of ingredients and dishes that the user likes to eat.

[1139] "Dietary restrictions" are restrictions on ingredients or nutrients that a user wants to avoid for reasons such as health or dieting.

[1140] "Allergy information" is information about ingredients that may cause an allergic reaction to the user.

[1141] "Dietary history" is a record of meals that a user has eaten in the past.

[1142] A "server" is a computer system that receives, stores, and analyzes user input information, and generates and provides recipes.

[1143] A "natural language processing module" is a technology for analyzing information entered by a user and understanding its meaning.

[1144] A "recipe generation algorithm" is a method for automatically generating optimal recipes based on a user's preferences and restrictions.

[1145] "Feedback" refers to the user's opinions and impressions about the recipe provided.

[1146] A "supplier" is a restaurant or delivery service provider that provides food to users.

[1147] A "terminal" is a device (e.g., smartphone, tablet) that a user uses to enter information and receive recipe suggestions.

[1148] A "database" is a system for storing and managing user information and feedback within a server.

[1149] "Machine learning algorithms" are technologies that analyze user feedback and improve future recipe suggestions.

[1150] This invention is a system that provides original recipes taking into account a user's preferences, dietary restrictions, allergy information, and dietary history, and further improves the recipes based on feedback. The system is primarily composed of a user terminal and a server. Specific embodiments of this system are described below.

[1151] First, the user inputs their preferences, allergy information, dietary restrictions, past dietary history, etc. into the terminal. For example, if a user likes chicken, dislikes onions, is allergic to nuts, and wishes to eat a low-calorie diet, they input this information into the terminal. The terminal then sends this information in an appropriate format to the server.

[1152] The server stores the received information in a database. The database stores profile information for each user. Next, the server uses a natural language processing module (e.g., SpaCy) to analyze the user information. This analysis identifies the user's preferences and restrictions. For example, "chicken" and "low calorie" are analyzed.

[1153] Based on the analysis results, the server runs a recipe generation algorithm (generative AI model) to generate the optimal recipe for the user. The generated recipe is then described in detail using natural language generation AI and sent to the device. The generated recipe is then displayed on the user's device. The recipe includes cooking instructions, a list of ingredients, required time, and important notes.

[1154] Furthermore, the server searches for and suggests suppliers (restaurants and delivery services) that offer the proposed dishes based on the generated recipe. The user can then place an order directly from the provided supplier. For example, a restaurant that offers a "low-calorie recipe using chicken and tomatoes" is suggested, and the user can then place an order.

[1155] After cooking is complete, the user can enter feedback on the recipe, such as "It was delicious, but I wish it had a bit more spice." This feedback information is sent back to the server, which stores it in a database.

[1156] The received feedback is analyzed by a machine learning algorithm (e.g., TensorFlow) on the server. The recipe generation algorithm is adjusted based on the feedback and reflected in future recipe generation. This allows the system to provide recipes that are more tailored to the user's preferences.

[1157] Hardware / Software used

[1158] Hardware: Smartphones, servers

[1159] Software: Android / iOS applications, Python, Django (web framework), natural language processing modules (e.g., SpaCy), machine learning models (e.g., TensorFlow)

[1160] Specific examples

[1161] User "Yamada Taro" uses the system to search for new recipes. He enters the following information into his profile:

[1162] Favorite ingredients: chicken, tomatoes

[1163] Disliked food: Onions

[1164] Allergies: Nuts

[1165] Dietary restrictions: low calorie

[1166] Generative AI model prompt example

[1167] Here are some example prompts for a generative AI model:

[1168] Based on the profile of user "Yamada Taro", generate low-calorie recipes that meet the following criteria:

[1169] Favorite ingredients: chicken, tomatoes

[1170] Disliked food: Onions

[1171] Allergens: Nut-free

[1172] Restrictions: Low calorie

[1173] The output format is:

[1174] Recipe Title

[1175] Materials used

[1176] Cooking Instructions

[1177] Travel time

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

[1179] Step 1:

[1180] The user inputs preferences, allergy information, dietary restrictions, and dietary history into the terminal. The user uses a smartphone application to input information such as, for example, they like chicken, they dislike onions, they are allergic to nuts, or they would like to eat a low-calorie diet. This information is entered into the terminal and sent to the server in an appropriate format. Input: Information about the user's preferences and restrictions. Output: Formatted user information sent to the server.

[1181] Step 2:

[1182] The server stores the received user information in a database. The server analyzes the received information and saves it in the database as profile information for each user. For example, information such as "User ID: 123, likes chicken, dislikes onions, allergy to nuts, prefers low-calorie food" is stored. Input: User information sent from the terminal. Output: User profile saved in the database.

[1183] Step 3:

[1184] The server uses a natural language processing module (e.g., SpaCy) to analyze user preferences, dietary restrictions, and allergy information. The server tokenizes the text data and appropriately tags it to semantically understand each user's preferences and restrictions. For example, preferences and restrictions for ingredients such as "chicken," "onions," and "nuts" are analyzed. Input: User profile stored in a database. Output: Analyzed preference and restriction information.

[1185] Step 4:

[1186] The server runs a recipe generation algorithm (generative AI model) based on the analysis results to generate the optimal recipe for the user. The server uses the analyzed data as prompts to input into the generative AI model. For example, a recipe is generated based on a prompt such as "User ID: 123, Favorite ingredients: Chicken, Avoided ingredients: Onion, Nut allergy, Low calorie." Input: Analyzed preferences and restriction information. Output: Generated customized recipe.

[1187] Step 5:

[1188] The server uses natural language generation AI to describe the generated recipe in detail and sends it to the device. The server then describes each step of the generated recipe, the list of ingredients, the time required, and important points in natural language in detail and sends it to the user's device. For example, a "low-calorie recipe using chicken and tomatoes" is sent along with detailed instructions. Input: The generated customized recipe. Output: A detailed recipe document sent to the user's device.

[1189] Step 6:

[1190] The device displays the generated recipe. The recipe sent to the user's device is displayed through the application. The user checks the recipe, prepares the necessary ingredients, and starts cooking. For example, "Low-calorie dish using chicken and tomatoes" is displayed. Input: Detailed recipe sent from the server. Output: Recipe displayed on the device.

[1191] Step 7:

[1192] The server searches for suppliers that offer the proposed dishes based on the generated recipe and suggests them to the terminal. The server searches a database of restaurants and delivery services to suggest suppliers that offer dishes that match the user's preferences and restrictions. For example, it may suggest to the user information such as "nearby Restaurant A offers this dish." Input: Generated recipe and supplier database. Output: Supplier suggestion information.

[1193] Step 8:

[1194] The user places an order directly from the suggested supplier. The user orders food directly from the suggested restaurant or delivery service through the application. For example, a user can "order a low-calorie menu item with chicken and tomatoes from Restaurant A." Input: Supplier information. Output: Order confirmation information.

[1195] Step 9:

[1196] The user inputs feedback about the recipe into the terminal and sends it to the server. After cooking or ordering, the user inputs their opinions and thoughts about the recipe and sends it to the server via the terminal. For example, feedback such as "It was delicious, but I wish it was a little more spiced" is input. Input: User feedback information. Output: Feedback sent to the server.

[1197] Step 10:

[1198] The server stores the received feedback in a database and analyzes it using a machine learning algorithm (e.g., TensorFlow). The server stores the feedback data in a database and analyzes it using a machine learning algorithm to optimize the recipe generation algorithm for future uses. Input: Feedback information sent by the user. Output: Analyzed feedback and optimized recipe generation algorithm.

[1199] Step 11:

[1200] The next recipe is generated based on the optimized recipe generation algorithm and provided to the user. The server uses the optimized recipe generation algorithm based on the feedback to generate subsequent recipes and provide more personalized suggestions to the user. Input: Optimized recipe generation algorithm. Output: Next customized recipe.

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

[1202] The present invention combines a system that provides original recipes based on a user's preferences, dietary restrictions, allergy information, and dietary history with an emotion engine that recognizes the user's emotions. By taking the user's emotional state into account, the system can provide more personalized recipes.

[1203] System Overview

[1204] The system consists of a device used by the user, a server that supports it, and an emotion engine. Users input profile information such as preferences, dietary restrictions, allergies, and dietary history through their device. At the same time, the emotion engine recognizes the user's emotions and collects that information. This information is sent to the server, which generates recipes based on that information and also receives feedback and makes improvements.

[1205] Program processing

[1206] User: The user first launches the application and logs in. They enter profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I prefer a low-calorie diet." The application also reads the user's emotions through facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[1207] Device: The entered profile information and emotion information is sent to the server using a common data format such as JSON.

[1208] Server: Stores the received profile information and emotion information in a database. A unique ID is assigned to each user, and the profile information and emotion information are classified and organized.

[1209] Server: Analyzes profile information and emotional information using a natural language processing module and emotion engine. From the information, the server identifies the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[1210] Server: Runs a recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe." The recipe's difficulty, time required, and availability of ingredients are also taken into account.

[1211] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[1212] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[1213] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[1214] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[1215] Terminal: After cooking, a rating form is displayed to the user. A star rating (1 to 5 stars) and a comment input field are provided. The user's feelings after cooking are also collected again.

[1216] User: Enter feedback about the cooking. For example, enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send another emotional response.

[1217] Terminal: Sends the input feedback and emotion information to the server. Feedback data is also sent in JSON format.

[1218] Server: Stores the received feedback and emotional information in a database and analyzes it. It identifies common comments and evaluation points based on the feedback content and emotional information.

[1219] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[1220] In this way, the present invention provides customized recipes based on a user's preferences, dietary restrictions, allergy information, and even emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

[1221] The processing flow will be explained below.

[1222] Step 1:

[1223] User: Launches the application and logs in. Enters profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I would like a low-calorie diet." At the same time, the emotion engine obtains the user's emotions through facial recognition and voice analysis, and acquires emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[1224] Step 2:

[1225] Device: The entered profile information and emotion information is sent to the server using a common data format such as JSON.

[1226] Step 3:

[1227] Server: Stores the received profile information and emotion information in a database. A unique ID is assigned to each user, and the profile information and emotion information are classified and organized.

[1228] Step 4:

[1229] Server: Analyzes profile information and emotional information using a natural language processing module and emotion engine. From the information, the server identifies the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[1230] Step 5:

[1231] Server: Runs a recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe." The recipe's difficulty, time required, and availability of ingredients are also taken into account.

[1232] Step 6:

[1233] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[1234] Step 7:

[1235] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[1236] Step 8:

[1237] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[1238] Step 9:

[1239] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[1240] Step 10:

[1241] Terminal: After cooking, a rating form is displayed to the user. A star rating (1 to 5 stars) and a comment input field are provided. The user's feelings after cooking are also collected again.

[1242] Step 11:

[1243] User: Enter feedback about the cooking. For example, enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send another emotional response.

[1244] Step 12:

[1245] Terminal: Sends the input feedback and emotion information to the server. Feedback data is also sent in JSON format.

[1246] Step 13:

[1247] Server: Stores the received feedback and emotional information in a database and analyzes it. It identifies common comments and evaluation points based on the feedback content and emotional information.

[1248] Step 14:

[1249] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[1250] In this way, the present invention provides customized recipes based on a user's preferences, dietary restrictions, allergy information, and even emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

[1251] Example 2

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

[1253] Conventional recipe provision systems were able to provide personalized recipes based on a user's preferences, dietary restrictions, allergy information, and dietary history, but they did not take into account the user's emotional state, making it difficult to provide recipes that were truly suited to each individual user. In particular, they were unable to take into account the fact that a user's mood and emotional state have a significant impact on appetite and ingredient selection, which limited the improvement of the user experience. In addition, the system was not sufficiently optimized through feedback analysis, and there was a lack of means to improve the system's accuracy.

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

[1255] In this invention, the server includes a means for storing received user information and emotional information in a database, a means for analyzing the user information and emotional information using a natural language processing module and an emotion engine, and a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user. This enables the provision of more personalized recipes that take into account the user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. Furthermore, by analyzing the received feedback and emotional information using a machine learning algorithm and reflecting this in the next recipe generation, the system can be continuously optimized and the user experience can be improved.

[1256] "User information" refers to personal profile information such as the user's preferences, dietary restrictions, allergy information, and dietary history.

[1257] "Emotion information" is information that indicates the user's mood or emotional state, such as whether the user is feeling stressed or relaxed.

[1258] A "server" is a computer system that receives, stores, analyzes user information and emotion information, and generates recipes.

[1259] A "natural language processing module" is a software module that analyzes input user information and extracts meaning from it.

[1260] An "emotion engine" is an algorithm or software that analyzes a user's facial recognition and voice data to identify the user's emotional state.

[1261] The "recipe generation algorithm" is an algorithm for generating an optimal recipe based on analyzed user information and emotional information.

[1262] A "natural language generation model" is an AI model that generates analysis results and recipes for users in natural-sounding sentences.

[1263] "Feedback" refers to response information such as user ratings and comments on the provided recipe.

[1264] "Machine learning algorithms" are algorithms used to optimize the performance of the system based on the feedback and sentiment information received.

[1265] This system provides original recipes by combining a user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. This system consists of a terminal used by the user, a server that supports it, and an emotion engine.

[1266] Hardware and software used

[1267] To realize this system, the following hardware and software are used:

[1268] Device: User device such as smartphone, tablet, or PC

[1269] Server: Cloud server or on-premise server

[1270] Database: Relational database such as MySQL or PostgreSQL

[1271] Natural language processing modules: Libraries such as SpaCy and NLTK

[1272] Emotion engine: facial recognition software, voice analysis tools

[1273] Recipe generation algorithms: Python scripts, algorithm libraries

[1274] Natural language generation models: AI models such as GPT-4

[1275] Machine learning algorithms: Libraries such as Scikit-Learn and TensorFlow

[1276] Program processing and specific examples

[1277] User: The user first launches the application and logs in. They enter profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I'd like a low-calorie diet." The application also reads the user's emotions through facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[1278] Device: The device sends the entered profile information and emotion information to the server. The data is sent in a common data format such as JSON.

[1279] Server: The server stores the received profile information and emotion information in a database. It assigns a unique ID to each user and organizes the profile information and emotion information.

[1280] Server: The profile information and sentiment information are then analyzed by a natural language processing module and sentiment engine, which identifies the user's preferences, allergies, dietary restrictions, and emotional state.

[1281] Server: Runs the recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[1282] Server: The selected recipes are converted into text using natural language generation AI (e.g., GPT-4), which then details the recipe steps, ingredient list, cooking time, and precautions.

[1283] Server: Sends the generated recipe data to the user's device.

[1284] Device: The device displays the submitted recipe in a visually friendly format, including the recipe title, ingredients list, cooking steps, cooking time, difficulty level, etc.

[1285] User: The user prepares ingredients based on the displayed recipe and begins cooking. While cooking, the user continues to follow the instructions while referring to the device.

[1286] Terminal: After cooking, the terminal displays a rating form to the user, providing a star rating (1-5 stars) and a comment input field, and also collecting emotional information.

[1287] User: Enter feedback. Example: Enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send emotional information again.

[1288] Device: Sends rating and emotion information to the server. Feedback data is also sent in JSON format.

[1289] Server: The received feedback and emotional information are stored in a database and analyzed. Common comments and evaluation points are identified based on the feedback content and emotional information.

[1290] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback information and sentiment information. This information is reflected in future recipe suggestions.

[1291] Prompt Sentence Examples

[1292] As a concrete example, consider a case where a user wants a recipe that is low in calories and has a stress-relieving effect. Here is an example prompt to input to the generative AI model:

[1293] User Preference Profile:

[1294] Favorite ingredients: chicken, tomatoes

[1295] Disliked food: Onions

[1296] Allergens: nuts

[1297] Dietary restrictions: Low calorie

[1298] Emotional state: Stressed

[1299] Please suggest a recipe that meets these criteria, including a specific ingredient list, cooking instructions, cooking time, and any warnings.

[1300] In this way, the system can provide customized recipes based on the user's preferences, dietary restrictions, allergy information, and even emotional state, and use that feedback to improve the system's accuracy.

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

[1302] Step 1:

[1303] User: A user launches an application and logs in.

[1304] Input: User ID, Password

[1305] Output: Login success or failure message

[1306] Specific operation: The user starts the application and enters their user ID and password on the login screen. When they press the "Login" button, the device sends the entered information to the server. The server compares it with the user information database and returns a message to the device indicating whether the login was successful. If a success message is displayed, the user can proceed to the next step.

[1307] Step 2:

[1308] User: Enters preferences, dietary restrictions, allergy information, past dietary history, and emotional state.

[1309] Input: food preferences, dietary restrictions, allergy information, past dietary information, emotional information

[1310] Output: Confirmation message for input contents

[1311] How it works: Users fill out a form in the application to enter their preferences, dietary restrictions, allergies, and dietary history, and provide their emotional state using facial recognition and voice input. When they press the "Send" button, the device sends this information to the server in JSON format.

[1312] Step 3:

[1313] Terminal: Sends the entered profile information and emotion information to the server.

[1314] Input: JSON format profile information, emotion information

[1315] Output: Message indicating that the data sent to the server has been sent successfully

[1316] Specific operation: JSON data containing profile information and emotion information is sent to the server via HTTPS. After sending, the device displays a message to the user indicating completion of sending.

[1317] Step 4:

[1318] Server: Stores the received data in a database.

[1319] Input: JSON format profile information, emotion information

[1320] Output: Database update completion message

[1321] Specific operation: The server parses the received JSON data and stores it in a relational database such as MySQL or PostgreSQL. A unique ID is assigned to each user data item and the data is properly organized. A completion message is generated when the database update is complete.

[1322] Step 5:

[1323] Server: Analyzes user information and emotional information using a natural language processing module and emotion engine.

[1324] Input: Profile information and emotion information stored in the database

[1325] Output: Analysis results (user preferences, allergies, dietary restrictions, emotional state)

[1326] How it works: Using natural language processing modules (e.g., SpaCy or NLTK) and emotion engines (facial recognition software, speech analysis tools), the system analyzes profile information and emotional information. The results of the analysis are used to identify and extract new user preferences, allergies, dietary restrictions, and emotional state, and store them in a database.

[1327] Step 6:

[1328] Server: Executes the recipe generation algorithm based on the analysis results.

[1329] Input: Analysis results (user preferences, allergies, dietary restrictions, emotional state)

[1330] Output: Generated recipe information

[1331] How it works: Using a recipe generation algorithm (Python script or algorithm library), the system searches the database for the best recipe based on the analysis results and generates a customized recipe for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[1332] Step 7:

[1333] Server: Uses natural language generation AI to write down the details of the generated recipe.

[1334] Input: Generated recipe information

[1335] Output: Written recipe details

[1336] What it does: It uses a natural language generation model (e.g., GPT-4) to generate natural-sounding details for the generated recipe, including information like ingredient lists, cooking instructions, cooking times, and warnings.

[1337] Step 8:

[1338] Server: Sends the generated recipe data to the user's device.

[1339] Input: Written recipe details

[1340] Output: A message to the terminal indicating that transmission is complete

[1341] Specific operation: The generated recipe data is converted to JSON format and sent to the user's device. A transmission completion message is generated on the server side.

[1342] Step 9:

[1343] Terminal: Displays submitted recipes in a visually friendly format.

[1344] Input: Recipe data in JSON format

[1345] Output: Recipe display screen

[1346] Specific operation: The device parses the JSON format recipe data received and displays the recipe information visually in an easy-to-understand manner on a GUI (Graphical User Interface). This is implemented using libraries such as Vue.js and React.

[1347] Step 10:

[1348] User: Prepare ingredients and start cooking.

[1349] Input: Recipe details

[1350] Output: Finished dish

[1351] Specific operation: The user gathers the necessary ingredients based on the displayed recipe and begins cooking according to the instructions. During cooking, the user refers to the device screen for each step and uses the "Next" button to proceed through the steps.

[1352] Step 11:

[1353] Terminal: Display the evaluation form after cooking.

[1354] Input: None (cooking completion trigger)

[1355] Output:Evaluation form display

[1356] Specific operation: Once cooking is complete, the device will automatically display a rating form in a pop-up window, etc. The rating form includes a star rating (1-5 stars) and a comment input field, as well as an option to obtain additional emotional information.

[1357] Step 12:

[1358] Users: Enter your rating and feedback.

[1359] Input: Rating (star rating and comments), sentiment information

[1360] Output: Sending rating and sentiment data

[1361] Specific operation: The user enters a star rating and a comment in the rating form, and then presses the "Submit" button to send the feedback and emotional information. The content is sent from the device to the server in JSON format.

[1362] Step 13:

[1363] Terminal: Sends ratings and emotion information to the server.

[1364] Input: Evaluation information, emotion information

[1365] Output: Message sent to server

[1366] Specific operation: The input rating and emotion information is converted into JSON format and sent to the server using the HTTPS protocol. After the transmission is complete, the device displays a completion message.

[1367] Step 14:

[1368] Server: Stores the received ratings and emotion information in a database and performs analysis.

[1369] Input: Feedback and sentiment information in JSON format

[1370] Output: Analysis complete message

[1371] Specific operation: The received feedback and emotional information are stored in a database, and analyzed using the analysis module. Common comments and evaluation points are identified from the feedback content and emotional information, and the analysis results are stored in the database.

[1372] Step 15:

[1373] Server: Optimizes the recipe generation algorithm using machine learning algorithms.

[1374] Input: Analysis results, feedback information, emotion information

[1375] Output: Optimized recipe generation algorithm

[1376] How it works: Using machine learning algorithms (e.g., Scikit-Learn or TensorFlow), the recipe generation algorithm is optimized based on the analysis results, feedback, and sentiment information. Once the optimization is complete, the algorithm is reflected in the next recipe generation.

[1377] (Application example 2)

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

[1379] Conventional recipe suggestion systems generate recipes based only on the user's preferences, dietary restrictions, allergy information, and dietary history, resulting in insufficient personalization based on the user's emotional state. Furthermore, there are limitations to their application in brick-and-mortar establishments such as restaurants, and challenges remain in improving motivation and satisfaction in line with the user's emotions. In particular, there is a need for systems that can provide optimal meal menus tailored to the customer's emotional state.

[1380] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for inputting a user's preferences, dietary restrictions, allergy information, and dietary history; means for transmitting the input information to the server; means for storing the received user information in a database; means for analyzing the user information using a natural language processing module; means for executing a recipe generation algorithm based on the analysis results and generating a recipe optimal for the user; means for transmitting the generated recipe to the user's terminal; means for displaying the transmitted recipe on the user's terminal; means for transmitting user feedback to the server; means for storing and analyzing the received feedback in a database; means for optimizing the recipe generation algorithm based on the analysis results; an emotion recognition engine for recognizing the user's emotional state; means for transmitting the recognized emotion information to the server; and means for generating a recipe appropriate for the user's emotional state based on the emotion information and profile information. This enables personalized recipe suggestions based on the user's emotional state, thereby improving customer satisfaction even in physical stores.

[1381] "User preferences" refers to the user's preferred foods, ingredients, seasoning preferences, etc.

[1382] "Dietary Restrictions" refers to restrictions on foods or nutrients that a user should avoid for health reasons or personal preferences.

[1383] "Allergy information" is information about foods and ingredients that may cause a user an allergic reaction.

[1384] "Dietary history" is information about the contents of meals the user has eaten in the past and their history.

[1385] An "emotion recognition engine" is a system that recognizes a user's emotional state from their facial expressions, voice, etc., and converts it into digital data.

[1386] "Profile information" is comprehensive personal information such as the user's preferences, dietary restrictions, allergy information, and dietary history.

[1387] A "natural language processing module" refers to a program or algorithm that analyzes input text information and understands its meaning.

[1388] A "recipe generation algorithm" is a calculation method for generating an optimal recipe based on a user's profile information.

[1389] "Feedback" refers to ratings and comments that users make about recipes and services provided.

[1390] A "machine learning algorithm" is an algorithm that improves system performance based on feedback and usage history.

[1391] The "database" is a system for efficiently managing and storing user information, profile information, generated recipes, feedback, etc.

[1392] This invention relates to a system that provides optimal recipes based on a user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. This system is composed of a terminal used by the user, a server, and an emotion recognition engine.

[1393] First, the user launches the application on a device such as a smartphone or tablet and logs in. After that, the user enters their preferences, dietary restrictions, allergy information, and dietary history. An emotion recognition engine then recognizes emotions from the user's face and voice, and this information is also acquired. This information is then sent from the device to the server in JSON format or similar.

[1394] The information received by the server is stored in a database, where it is categorized and organized by assigning a unique ID to each user. The server then uses a natural language processing module and an emotion recognition engine to analyze the user's profile information and emotional information. Based on the analysis results, a recipe generation algorithm is executed to search for and customize the optimal recipe. For example, a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe" is generated. The recipe's difficulty, required time, and ease of obtaining ingredients are also taken into consideration.

[1395] The generated recipe is then written in detail using natural language generation AI, including specific recipe steps, ingredient lists, cooking times, and important notes. This information is then sent back to the device in JSON format, where users can view it in a visually easy-to-understand format.

[1396] The user creates a dish based on the recipe and is presented with a feedback form to rate the results. A star rating (1-5 stars) and a comment input field are provided, and emotional information after cooking is also collected. This feedback and emotional information is again sent from the device to the server. The server stores the received feedback in a database and analyzes it. Based on the results of this analysis, a machine learning algorithm optimizes the recipe generation algorithm and reflects it in future recipe suggestions.

[1397] For example, if a user's profile information is "Favorite ingredients are chicken and tomatoes, least favorite ingredients are onions, allergies are nuts, and a low-calorie diet is desired," and the emotion recognition engine recognizes that the user is "feeling good today," it will suggest a "low-calorie chicken and tomato recipe."An example of a prompt sentence is as follows:

[1398] Example prompt sentence:

[1399] User profile: Favorite foods are chicken and tomatoes, dislikes onions, allergies to nuts. Prefers low-calorie meals.

[1400] Today's feeling: I feel good.

[1401] Generate optimal recipes based on this profile and sentiment.

[1402] In this way, the present invention provides recipes customized based on the user's preferences, dietary restrictions, allergy information, and emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

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

[1404] Step 1:

[1405] The user launches the application on their device and logs in. The user enters their preferences, dietary restrictions, allergy information, and dietary history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I prefer a low-calorie diet." The input data is converted to JSON format.

[1406] Input: User preferences, dietary restrictions, allergy information, dietary history

[1407] Output: Profile information in JSON format

[1408] Step 2:

[1409] The emotion recognition engine reads the user's emotions from facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[1410] Input: User's facial image or voice data

[1411] Output: Emotional information

[1412] Step 3:

[1413] The device sends profile information (step 1) and emotion information (step 2) to the server. The data is sent in JSON format.

[1414] Input: JSON format profile information, emotion information

[1415] Output: Send data to the server

[1416] Step 4:

[1417] The server stores the received profile information and emotion information in a database. Each user is assigned a unique ID and classified and organized.

[1418] Input: JSON format profile information, emotion information

[1419] Output: Store in database

[1420] Step 5:

[1421] The server analyzes the received data using a natural language processing module and an emotion recognition engine, thereby identifying the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[1422] Input: Profile information and emotion information stored in the database

[1423] Output: Analysis results (user preferences, allergy information, dietary restrictions, emotional state)

[1424] Step 6:

[1425] The server runs a recipe generation algorithm based on the analysis results, searching for suitable recipes from a database and customizing them for the user. For example, it generates a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[1426] Input: Analysis results

[1427] Output: Customized recipe data

[1428] Step 7:

[1429] The server uses natural language generation AI to translate the details of the generated recipe into text, including recipe steps, ingredient list, cooking time, and important notes.

[1430] Input: Customized recipe data

[1431] Output: A written recipe

[1432] Step 8:

[1433] The server sends the generated recipe to the user's terminal, and sends the recipe data in response to the request.

[1434] Input: Written recipe

[1435] Output: Send recipe to terminal

[1436] Step 9:

[1437] The device displays the recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty level, and other information in a visually easy-to-understand format.

[1438] Input: Data to send to the terminal

[1439] Output: A visual representation of the recipe

[1440] Step 10:

[1441] The user checks the displayed recipe, prepares the necessary ingredients, and begins cooking. While cooking, the user continues to follow the instructions while referring to the device.

[1442] Input: Display recipe to user

[1443] Output: User cooking action

[1444] Step 11:

[1445] After cooking, the device displays a rating form to the user, providing a star rating (1 to 5 stars) and a comment input field. The device also collects the user's feelings after cooking.

[1446] Input: User operation after recipe cooking

[1447] Output: Evaluation form, retrieved emotional information

[1448] Step 12:

[1449] The user enters feedback about the cooking, for example, "4 stars, it was delicious but I'd like to add a little spice," and also submits emotional information.

[1450] Input: Evaluation form, comments, sentiment information

[1451] Output: Feedback data

[1452] Step 13:

[1453] The device sends the input feedback and emotion information to the server, and the data is again sent in JSON format.

[1454] Input: Feedback data

[1455] Output: Send data to the server

[1456] Step 14:

[1457] The server stores the received feedback and emotional information in a database and analyzes it. It identifies frequently occurring comments and evaluation points based on the feedback content and emotional information.

[1458] Input: Feedback data, emotional information

[1459] Output: Parsed data

[1460] Step 15:

[1461] The server uses a machine learning algorithm to optimize the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[1462] Input: Parsed data

[1463] Output: Optimized recipe generation algorithm

[1464] Through these processing steps, the present invention is able to provide and continually improve personalized recipes that take into account a user's preferences, dietary restrictions, allergy information, and emotional state.

[1465] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

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

[1467] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[1468] [Fourth embodiment]

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

[1470] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

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

[1472] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

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

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

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

[1476] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1477] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

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

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

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

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

[1482] The present invention is a system that provides original recipes that take into account the user's preferences, dietary restrictions, allergy information, and dietary history. This system mainly involves a process in which the user inputs information through a terminal, the server generates recipes based on that information, and then receives feedback and makes improvements.

[1483] System Overview

[1484] The system consists of a device used by the user and a server that supports it. Users enter profile information such as preferences, dietary restrictions, allergies, and dietary history through their own device. This information is sent to the server, which stores it in a database. Here, a natural language processing module analyzes the user information and runs a recipe generation algorithm to generate the optimal recipe for the user.

[1485] Program processing

[1486] User: The user first launches the application and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, they can enter chicken as their favorite food, onions as their least favorite food, nuts as their allergic food, and request a low-calorie diet.

[1487] Terminal: The entered information is sent from the user's terminal to the server. The terminal sends this information in the appropriate format so that the server can receive it.

[1488] Server: The server stores the received information in a database, which stores each user's profile information. A natural language processing module then analyzes the stored information to identify the user's preferences and restrictions.

[1489] Server: The recipe generation algorithm is executed based on the analysis results. The algorithm searches the database for relevant recipes and customizes them to suit the user's preferences and restrictions. For example, a "low-calorie recipe using chicken and tomatoes" may be generated. The algorithm also takes into account the difficulty of the recipe, the time required, and the difficulty of obtaining ingredients, so recipes that are easy for beginners to follow are provided.

[1490] Server: The generated recipe is described in detail by natural language generation AI and sent to the user's device.

[1491] Device: The generated recipe is displayed on the user's device. The user checks the recipe, prepares the necessary ingredients, and starts cooking. The recipe includes cooking instructions, a list of ingredients, cooking time, and important notes.

[1492] User: After cooking is complete, the user can provide feedback on the recipe. For example, they can comment, "It was delicious, but I wish it had a few more spices."

[1493] Terminal: The feedback information is sent back to the server, which stores it in a database.

[1494] Server: The received feedback is analyzed using a machine learning algorithm. The recipe generation algorithm is adjusted based on the feedback and reflected in future recipe generation. This allows the system to provide recipes that are more tailored to the user's preferences.

[1495] In this way, the present invention is a system that can generate and provide optimal original recipes taking into account the user's preferences, dietary restrictions, and allergy information. Furthermore, it is possible to continuously improve the recipe generation algorithm based on user feedback, realizing an optimal diet for each individual user.

[1496] The processing flow will be explained below.

[1497] Step 1:

[1498] User: Launches the application and logs in. Enters profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite foods are chicken and tomatoes, my least favorite foods are onions, I'm allergic to nuts, and I prefer a low-calorie diet."

[1499] Step 2:

[1500] Device: The entered profile information is sent to the server using a common data format such as JSON.

[1501] Step 3:

[1502] Server: Stores the received profile information in a database. A unique ID is assigned to each user, and the profile information is categorized and organized.

[1503] Step 4:

[1504] Server: Analyzes profile information using a natural language processing module, identifies user preferences, allergies, and dietary restrictions from the information, and extracts analysis results.

[1505] Step 5:

[1506] Server: Runs the recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. This takes into account the difficulty of the recipe, the time required, and the ease of obtaining ingredients. For example, it selects a "low-calorie recipe with chicken and tomatoes."

[1507] Step 6:

[1508] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[1509] Step 7:

[1510] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[1511] Step 8:

[1512] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[1513] Step 9:

[1514] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[1515] Step 10:

[1516] Terminal: After cooking, a rating form is displayed to the user, providing a star rating (1 to 5 stars) and a comment input field.

[1517] Step 11:

[1518] User: Enter feedback about the cooking. For example, enter a comment like "4 stars, it was delicious but I'd like it to be a little spiced up."

[1519] Step 12:

[1520] Terminal: Sends the entered feedback to the server. Feedback data is also sent in JSON format.

[1521] Step 13:

[1522] Server: Stores the received feedback in a database and analyzes it. It identifies common comments and evaluation points from the feedback.

[1523] Step 14:

[1524] Server: The machine learning algorithm optimizes the recipe generation algorithm based on the feedback information. The feedback is used as learning data to be reflected in future recipe generation.

[1525] In this way, the present invention provides recipes that are customized based on a user's preferences, dietary restrictions, and allergy information, and can continuously improve their accuracy based on user feedback.

[1526] Example 1

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

[1528] Conventional recipe provision systems have had the problem of being unable to provide original recipes that fully take into account the user's preferences, dietary restrictions, allergy information, and dietary history. Furthermore, there were few systems that could efficiently analyze user feedback and reflect it in the next recipe generation. This made it difficult to provide recipes that were suited to each individual user, and there was a need to improve user satisfaction.

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

[1530] In this invention, the server includes a means for storing received user information in a database, a means for analyzing the user information using a natural language processing module, a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user, and a means for describing the generated recipe in detail using a natural language generation model and transmitting the description to the user's terminal. This makes it possible to provide optimal recipes that take into account the user's individual preferences and dietary restrictions. In addition, user feedback can be analyzed using a machine learning algorithm and reflected in the next recipe generation, enabling continuous system optimization.

[1531] "User" refers to a person who uses a terminal to input information such as preferences, dietary restrictions, allergy information, and dietary history, and receives the optimal recipe from the system.

[1532] "Preferences" is information that indicates the specific ingredients or types of dishes that a user likes.

[1533] "Dietary Restrictions" refers to information about specific ingredients or foodstuffs that a user should avoid consuming.

[1534] "Allergy information" is information about specific ingredients to which a user may have an allergic reaction.

[1535] "Dietary history" is information about a record of meals the user has taken in the past and their evaluations.

[1536] "Terminal" refers to the hardware device through which a user inputs information and checks recipes, such as a smartphone, tablet, or PC.

[1537] A "server" is a computer system that receives information sent by users, stores it in a database, and performs analysis and recipe generation.

[1538] A "database" is a digital storage system for storing user information, generated recipes, feedback information, and the like.

[1539] A "natural language processing module" is a software module for analyzing received user information and understanding text data.

[1540] A "recipe generation algorithm" is a series of calculations used to generate optimal recipes based on a user's preferences, dietary restrictions, etc.

[1541] A "natural language generation model" is an AI technology that describes the generated recipe in detail and provides it to the user in natural language.

[1542] "Feedback" refers to comments that users can send to the system, such as their thoughts, ratings, and suggestions for improvement regarding the provided recipe.

[1543] A "machine learning algorithm" is a learning method that analyzes user feedback and reflects it in the next recipe generation.

[1544] The present invention is a system that provides original recipes that take into account the user's preferences, dietary restrictions, allergy information, and dietary history. This system involves a process in which the user inputs information through a terminal, the server generates recipes based on that information, and the system receives feedback and makes improvements.

[1545] Hardware and software used

[1546] Device: The device used by the user, such as a smartphone, tablet, or PC (e.g., iOS, Android, Windows, macOS).

[1547] Server: Cloud server (e.g. AWS, Google Cloud, Microsoft Azure).

[1548] software:

[1549] Natural language processing modules (e.g. spaCy, NLTK).

[1550] Recipe generation algorithms (custom algorithms, machine learning models).

[1551] Database (e.g. MySQL, PostgreSQL).

[1552] Natural language generation AI (e.g. GPT-3, ChatGPT).

[1553] Program Processing Details

[1554] User: First, the user launches a dedicated application on their device and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, the user might fill in the input form with "Favorite food: chicken," "Disliked food: onion," "Allergy: nuts," "Desired: low calorie," etc.

[1555] Terminal: The terminal encrypts the information entered by the user using HTTPS and sends it to the server via a REST API. The terminal converts the information into JSON format and sends a request to the appropriate API endpoint.

[1556] Server: The server analyzes the received information and stores it in a database. The database stores each user's profile information. The server then analyzes the user information using a natural language processing module (e.g., spaCy), tokenizing the text data and identifying keywords such as "favorite ingredients" or "allergies." It then identifies the user's preferences and restrictions and prepares the analysis results.

[1557] Server: Runs a recipe generation algorithm based on the analysis results. This algorithm searches the database for suitable recipes. For example, it prioritizes recipes that use "chicken and tomato" or low-calorie recipes. The generated recipe is then written in detailed text using natural language generation AI (e.g., GPT-3). The generation AI generates the recipe name "Low-calorie chicken and tomato salad," along with cooking instructions, ingredient list, required time, and precautions.

[1558] Server: The generated recipe is sent to the user's device via the REST API in JSON format.

[1559] Device: The user's device receives the data from the server and displays the recipe on the app's UI. The user can check this information, prepare the necessary ingredients, and start cooking.

[1560] User: After cooking is complete, the user can enter feedback about the recipe through the application. For example, they can comment in the text box, "It was delicious, but I would like it to be a little more spiced."

[1561] Terminal: The feedback information entered by the user is again sent from the terminal to the server. This process is also encrypted using HTTPS and sent via the REST API, just like the information sending step.

[1562] Server: The received feedback is analyzed by a machine learning algorithm. The server analyzes the feedback using a natural language processing module and classifies the feedback content by element. For example, it extracts positive comments such as "delicious" and "I'd like to add some spices" as well as requests for improvement. The recipe generation algorithm is adjusted based on the analysis results. The feedback content is added as a new data point to the algorithm's training data, and the model is retrained, so that it is reflected in future recipe generation.

[1563] Examples of concrete examples and prompts

[1564] Examples:

[1565] User: "I like chicken, hate onions, and I'm allergic to nuts. I'd also like to eat a low-calorie diet."

[1566] Recipe generated from the server: "Low-calorie salad with chicken and tomatoes. Cooking instructions: 1. Boil the chicken. 2. Chop the tomatoes. 3. Mix the chicken and tomatoes and toss with olive oil."

[1567] Example prompt for generative AI model:

[1568] User Information:

[1569] Favorite food: Chicken

[1570] Disliked food: Onions

[1571] Allergies: Nuts

[1572] Desired: Low calorie

[1573] Use this information to generate low-calorie recipes tailored to your users.

[1574] In this way, the present invention creates a system that can generate and provide optimal original recipes taking into account the user's preferences, dietary restrictions, and allergy information. Furthermore, it is possible to continuously improve the recipe generation algorithm based on user feedback, realizing an optimized diet for each individual user.

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

[1576] Step 1:

[1577] Information input step

[1578] User: First, the user launches a dedicated application on their device and enters their preferences, allergy information, dietary restrictions, past eating history, etc. For example, the user might fill in the input form with "Favorite food: chicken," "Disliked food: onion," "Allergy: nuts," "Want: low calories," etc. This information becomes data used to communicate the user's individual preferences and restrictions to the system.

[1579] Step 2:

[1580] Information transmission steps

[1581] Terminal: The terminal encrypts the information entered by the user using HTTPS and sends it to the server via the REST API. The terminal converts the information into JSON format and sends a request to the appropriate API endpoint. The input data (preferences, allergy information, dietary restrictions, dietary history) is encrypted and sent to the server.

[1582] Step 3:

[1583] Information storage step

[1584] Server: The server parses the received information and stores it in a database. This information includes the user's preferences, allergy information, dietary restrictions, and past dietary history. The database stores profile information for each user. The received input data is parsed and inserted into the "users" table using a database manipulation library (e.g., SQLAlchemy).

[1585] Step 4:

[1586] Information Analysis Step

[1587] Server: The server uses a natural language processing module (e.g., spaCy) to analyze user information. For example, it tokenizes text data and identifies keywords such as "favorite ingredients" and "allergies." As a result, the user's preferences and restrictions become clear. The input data is user information (preferences, allergy information, dietary restrictions), and this data is analyzed to output results such as "favorite ingredients: chicken" and "allergies: nuts."

[1588] Step 5:

[1589] Recipe Generation Steps

[1590] Server: Runs a recipe generation algorithm based on the analysis results. This algorithm searches the database for suitable recipes and customizes them to fit the user's preferences and restrictions. For example, it may prioritize recipes using "chicken and tomatoes" or low-calorie recipes. The analysis results are provided as input data, and a customized recipe is output based on them.

[1591] Step 6:

[1592] Recipe Description Steps

[1593] Server: The generated recipe is described in detail as text using natural language generation AI (e.g., GPT-3). The generation AI creates information such as the recipe name "Low-calorie chicken and tomato salad," cooking instructions, ingredient list, required time, and precautions. The input data is the analysis results and the generated recipe, and a detailed recipe is output based on this.

[1594] Step 7:

[1595] Recipe Send and View Steps

[1596] Server: The generated recipe is sent to the user's device. This is also sent in JSON format via the REST API. The generated recipe data is entered and converted into the format to be sent.

[1597] Device: The user's device receives the data from the server and displays it on the app's UI. The user can check the recipe details and start cooking through this UI. The received JSON data is converted into a format that is displayed in the UI.

[1598] Step 8:

[1599] Feedback Input Step

[1600] User: After cooking is complete, the user enters feedback about the recipe through the application. For example, they might comment in a text box, "It was delicious, but I'd like it to have a bit more spice." This feedback information becomes data to improve the recipe generation for future recipes.

[1601] Step 9:

[1602] Feedback submission step

[1603] Terminal: The feedback information entered by the user is again sent from the terminal to the server. This process, like the information sending step, is encrypted using HTTPS and sent via the REST API. The input data is the user's feedback content, which is encrypted and sent to the server.

[1604] Step 10:

[1605] Feedback Analysis Step

[1606] Server: The received feedback is analyzed using a machine learning algorithm. The server analyzes the feedback using a natural language processing module and classifies the feedback content by element. For example, it extracts positive comments such as "delicious" and "I'd like to add some spice" as well as requests for improvement. The feedback data is input and the content is output by category.

[1607] Step 11:

[1608] Algorithm Adjustment Steps

[1609] Server: Adjusts the recipe generation algorithm based on the analysis results. The feedback content is added as a new data point to the algorithm's training data, and the model is retrained. This is reflected in future recipe generation. The feedback analysis results are input, and an optimized algorithm is output.

[1610] Step 12:

[1611] Optimized recipe provision steps

[1612] Server: Based on user feedback, the algorithm is adjusted so that future recipes are more tailored to the individual user. This allows the user to receive recipes that are increasingly tailored to them. Using the optimized algorithm, new recipes are generated and output.

[1613] (Application example 1)

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

[1615] Many modern food delivery services offer a standard menu without adequately considering individual requirements such as user preferences, dietary restrictions, and allergy information. This makes it difficult for users to choose the right dish, and they may suggest dishes that do not accommodate allergies or dietary restrictions. This results in lower user satisfaction and a decrease in the frequency of use of food delivery services. Furthermore, the lack of a mechanism for incorporating feedback after an order to improve suggestions for the next order slows down the improvement of the user experience.

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

[1617] In this invention, the server includes means for inputting a user's preferences, dietary restrictions, allergy information, and dietary history, means for transmitting the input information to the server, and means for storing the received user information in a database. This enables the generation of optimal recipes that take into account the user's individual requirements. The server further includes means for analyzing the user information using a natural language processing module, means for executing a recipe generation algorithm based on the analysis results to generate an optimal recipe for the user, means for transmitting the generated recipe to the user's terminal, means for displaying the transmitted recipe on the user's terminal, and means for transmitting feedback from the user to the server. The server also includes means for storing and analyzing the received feedback in a database, means for optimizing the recipe generation algorithm based on the analysis results, means for searching for and suggesting suppliers that provide suggested dishes based on the generated recipe, and means for directly ordering from the suggested suppliers. This allows users to easily order dishes that suit their preferences and dietary restrictions, and the next suggestions are further optimized based on the feedback, significantly improving the user experience.

[1618] "User preferences" refer to the characteristics of ingredients and dishes that the user likes to eat.

[1619] "Dietary restrictions" are restrictions on ingredients or nutrients that a user wants to avoid for reasons such as health or dieting.

[1620] "Allergy information" is information about ingredients that may cause an allergic reaction to the user.

[1621] "Dietary history" is a record of meals that a user has eaten in the past.

[1622] A "server" is a computer system that receives, stores, and analyzes user input information, and generates and provides recipes.

[1623] A "natural language processing module" is a technology for analyzing information entered by a user and understanding its meaning.

[1624] A "recipe generation algorithm" is a method for automatically generating optimal recipes based on a user's preferences and restrictions.

[1625] "Feedback" refers to the user's opinions and impressions about the recipe provided.

[1626] A "supplier" is a restaurant or delivery service provider that provides food to users.

[1627] A "terminal" is a device (e.g., smartphone, tablet) that a user uses to enter information and receive recipe suggestions.

[1628] A "database" is a system for storing and managing user information and feedback within a server.

[1629] "Machine learning algorithms" are technologies that analyze user feedback and improve future recipe suggestions.

[1630] This invention is a system that provides original recipes taking into account a user's preferences, dietary restrictions, allergy information, and dietary history, and further improves the recipes based on feedback. The system is primarily composed of a user terminal and a server. Specific embodiments of this system are described below.

[1631] First, the user inputs their preferences, allergy information, dietary restrictions, past dietary history, etc. into the terminal. For example, if a user likes chicken, dislikes onions, is allergic to nuts, and wishes to eat a low-calorie diet, they input this information into the terminal. The terminal then sends this information in an appropriate format to the server.

[1632] The server stores the received information in a database. The database stores profile information for each user. Next, the server uses a natural language processing module (e.g., SpaCy) to analyze the user information. This analysis identifies the user's preferences and restrictions. For example, "chicken" and "low calorie" are analyzed.

[1633] Based on the analysis results, the server runs a recipe generation algorithm (generative AI model) to generate the optimal recipe for the user. The generated recipe is then described in detail using natural language generation AI and sent to the device. The generated recipe is then displayed on the user's device. The recipe includes cooking instructions, a list of ingredients, required time, and important notes.

[1634] Furthermore, the server searches for and suggests suppliers (restaurants and delivery services) that offer the proposed dishes based on the generated recipe. The user can then place an order directly from the provided supplier. For example, a restaurant that offers a "low-calorie recipe using chicken and tomatoes" is suggested, and the user can then place an order.

[1635] After cooking is complete, the user can enter feedback on the recipe, such as "It was delicious, but I wish it had a bit more spice." This feedback information is sent back to the server, which stores it in a database.

[1636] The received feedback is analyzed by a machine learning algorithm (e.g., TensorFlow) on the server. The recipe generation algorithm is adjusted based on the feedback and reflected in future recipe generation. This allows the system to provide recipes that are more tailored to the user's preferences.

[1637] Hardware / Software used

[1638] Hardware: Smartphones, servers

[1639] Software: Android / iOS applications, Python, Django (web framework), natural language processing modules (e.g., SpaCy), machine learning models (e.g., TensorFlow)

[1640] Specific examples

[1641] User "Yamada Taro" uses the system to search for new recipes. He enters the following information into his profile:

[1642] Favorite ingredients: chicken, tomatoes

[1643] Disliked food: Onions

[1644] Allergies: Nuts

[1645] Dietary restrictions: low calorie

[1646] Generative AI model prompt example

[1647] Here are some example prompts for a generative AI model:

[1648] Based on the profile of user "Yamada Taro", generate low-calorie recipes that meet the following criteria:

[1649] Favorite ingredients: chicken, tomatoes

[1650] Disliked food: Onions

[1651] Allergens: Nut-free

[1652] Restrictions: Low calorie

[1653] The output format is:

[1654] Recipe Title

[1655] Materials used

[1656] Cooking Instructions

[1657] Travel time

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

[1659] Step 1:

[1660] The user inputs preferences, allergy information, dietary restrictions, and dietary history into the terminal. The user uses a smartphone application to input information such as, for example, they like chicken, they dislike onions, they are allergic to nuts, or they would like to eat a low-calorie diet. This information is entered into the terminal and sent to the server in an appropriate format. Input: Information about the user's preferences and restrictions. Output: Formatted user information sent to the server.

[1661] Step 2:

[1662] The server stores the received user information in a database. The server analyzes the received information and saves it in the database as profile information for each user. For example, information such as "User ID: 123, likes chicken, dislikes onions, allergy to nuts, prefers low-calorie food" is stored. Input: User information sent from the terminal. Output: User profile saved in the database.

[1663] Step 3:

[1664] The server uses a natural language processing module (e.g., SpaCy) to analyze user preferences, dietary restrictions, and allergy information. The server tokenizes the text data and appropriately tags it to semantically understand each user's preferences and restrictions. For example, preferences and restrictions for ingredients such as "chicken," "onions," and "nuts" are analyzed. Input: User profile stored in a database. Output: Analyzed preference and restriction information.

[1665] Step 4:

[1666] The server runs a recipe generation algorithm (generative AI model) based on the analysis results to generate the optimal recipe for the user. The server uses the analyzed data as prompts to input into the generative AI model. For example, a recipe is generated based on a prompt such as "User ID: 123, Favorite ingredients: Chicken, Avoided ingredients: Onion, Nut allergy, Low calorie." Input: Analyzed preferences and restriction information. Output: Generated customized recipe.

[1667] Step 5:

[1668] The server uses natural language generation AI to describe the generated recipe in detail and sends it to the device. The server then describes each step of the generated recipe, the list of ingredients, the time required, and important points in natural language in detail and sends it to the user's device. For example, a "low-calorie recipe using chicken and tomatoes" is sent along with detailed instructions. Input: The generated customized recipe. Output: A detailed recipe document sent to the user's device.

[1669] Step 6:

[1670] The device displays the generated recipe. The recipe sent to the user's device is displayed through the application. The user checks the recipe, prepares the necessary ingredients, and starts cooking. For example, "Low-calorie dish using chicken and tomatoes" is displayed. Input: Detailed recipe sent from the server. Output: Recipe displayed on the device.

[1671] Step 7:

[1672] The server searches for suppliers that offer the proposed dishes based on the generated recipe and suggests them to the terminal. The server searches a database of restaurants and delivery services to suggest suppliers that offer dishes that match the user's preferences and restrictions. For example, it may suggest to the user information such as "nearby Restaurant A offers this dish." Input: Generated recipe and supplier database. Output: Supplier suggestion information.

[1673] Step 8:

[1674] The user places an order directly from the suggested supplier. The user orders food directly from the suggested restaurant or delivery service through the application. For example, a user can "order a low-calorie menu item with chicken and tomatoes from Restaurant A." Input: Supplier information. Output: Order confirmation information.

[1675] Step 9:

[1676] The user inputs feedback about the recipe into the terminal and sends it to the server. After cooking or ordering, the user inputs their opinions and thoughts about the recipe and sends it to the server via the terminal. For example, feedback such as "It was delicious, but I wish it was a little more spiced" is input. Input: User feedback information. Output: Feedback sent to the server.

[1677] Step 10:

[1678] The server stores the received feedback in a database and analyzes it using a machine learning algorithm (e.g., TensorFlow). The server stores the feedback data in a database and analyzes it using a machine learning algorithm to optimize the recipe generation algorithm for future uses. Input: Feedback information sent by the user. Output: Analyzed feedback and optimized recipe generation algorithm.

[1679] Step 11:

[1680] The next recipe is generated based on the optimized recipe generation algorithm and provided to the user. The server uses the optimized recipe generation algorithm based on the feedback to generate subsequent recipes and provide more personalized suggestions to the user. Input: Optimized recipe generation algorithm. Output: Next customized recipe.

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

[1682] The present invention combines a system that provides original recipes based on a user's preferences, dietary restrictions, allergy information, and dietary history with an emotion engine that recognizes the user's emotions. By taking the user's emotional state into account, the system can provide more personalized recipes.

[1683] System Overview

[1684] The system consists of a device used by the user, a server that supports it, and an emotion engine. Users input profile information such as preferences, dietary restrictions, allergies, and dietary history through their device. At the same time, the emotion engine recognizes the user's emotions and collects that information. This information is sent to the server, which generates recipes based on that information and also receives feedback and makes improvements.

[1685] Program processing

[1686] User: The user first launches the application and logs in. They enter profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I prefer a low-calorie diet." The application also reads the user's emotions through facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[1687] Device: The entered profile information and emotion information is sent to the server using a common data format such as JSON.

[1688] Server: Stores the received profile information and emotion information in a database. A unique ID is assigned to each user, and the profile information and emotion information are classified and organized.

[1689] Server: Analyzes profile information and emotional information using a natural language processing module and emotion engine. From the information, the server identifies the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[1690] Server: Runs a recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe." The recipe's difficulty, time required, and availability of ingredients are also taken into account.

[1691] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[1692] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[1693] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[1694] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[1695] Terminal: After cooking, a rating form is displayed to the user. A star rating (1 to 5 stars) and a comment input field are provided. The user's feelings after cooking are also collected again.

[1696] User: Enter feedback about the cooking. For example, enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send another emotional response.

[1697] Terminal: Sends the input feedback and emotion information to the server. Feedback data is also sent in JSON format.

[1698] Server: Stores the received feedback and emotional information in a database and analyzes it. It identifies common comments and evaluation points based on the feedback content and emotional information.

[1699] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[1700] In this way, the present invention provides customized recipes based on a user's preferences, dietary restrictions, allergy information, and even emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

[1701] The processing flow will be explained below.

[1702] Step 1:

[1703] User: Launches the application and logs in. Enters profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I would like a low-calorie diet." At the same time, the emotion engine obtains the user's emotions through facial recognition and voice analysis, and acquires emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[1704] Step 2:

[1705] Device: The entered profile information and emotion information is sent to the server using a common data format such as JSON.

[1706] Step 3:

[1707] Server: Stores the received profile information and emotion information in a database. A unique ID is assigned to each user, and the profile information and emotion information are classified and organized.

[1708] Step 4:

[1709] Server: Analyzes profile information and emotional information using a natural language processing module and emotion engine. From the information, the server identifies the user's preferences, allergies, dietary restrictions, and emotional state, and extracts the analysis results.

[1710] Step 5:

[1711] Server: Runs a recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe." The recipe's difficulty, time required, and availability of ingredients are also taken into account.

[1712] Step 6:

[1713] Server: Using natural language generation AI, the details of the generated recipe are written into text, specifically describing the recipe steps, ingredient list, cooking time, precautions, etc.

[1714] Step 7:

[1715] Server: Sends the generated recipe to the user's device. Sends the recipe data in response to the request.

[1716] Step 8:

[1717] Device: Displays the submitted recipe to the user, including the recipe title, ingredients list, cooking steps, cooking time, difficulty, etc. in a visually easy-to-understand format.

[1718] Step 9:

[1719] User: Check the displayed recipe, prepare the necessary ingredients, and start cooking. While cooking, refer to the device and follow the instructions as you go.

[1720] Step 10:

[1721] Terminal: After cooking, a rating form is displayed to the user. A star rating (1 to 5 stars) and a comment input field are provided. The user's feelings after cooking are also collected again.

[1722] Step 11:

[1723] User: Enter feedback about the cooking. For example, enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send another emotional response.

[1724] Step 12:

[1725] Terminal: Sends the input feedback and emotion information to the server. Feedback data is also sent in JSON format.

[1726] Step 13:

[1727] Server: Stores the received feedback and emotional information in a database and analyzes it. It identifies common comments and evaluation points based on the feedback content and emotional information.

[1728] Step 14:

[1729] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback and emotion information. The feedback and emotion are used as learning data to be reflected in future recipe generation.

[1730] In this way, the present invention provides customized recipes based on a user's preferences, dietary restrictions, allergy information, and even emotional state, and can continuously improve its accuracy based on user feedback and emotional information.

[1731] Example 2

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

[1733] Conventional recipe provision systems were able to provide personalized recipes based on a user's preferences, dietary restrictions, allergy information, and dietary history, but they did not take into account the user's emotional state, making it difficult to provide recipes that were truly suited to each individual user. In particular, they were unable to take into account the fact that a user's mood and emotional state have a significant impact on appetite and ingredient selection, which limited the improvement of the user experience. In addition, the system was not sufficiently optimized through feedback analysis, and there was a lack of means to improve the system's accuracy.

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

[1735] In this invention, the server includes a means for storing received user information and emotional information in a database, a means for analyzing the user information and emotional information using a natural language processing module and an emotion engine, and a means for executing a recipe generation algorithm based on the analysis results to generate a recipe optimized for the user. This enables the provision of more personalized recipes that take into account the user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. Furthermore, by analyzing the received feedback and emotional information using a machine learning algorithm and reflecting this in the next recipe generation, the system can be continuously optimized and the user experience can be improved.

[1736] "User information" refers to personal profile information such as the user's preferences, dietary restrictions, allergy information, and dietary history.

[1737] "Emotion information" is information that indicates the user's mood or emotional state, such as whether the user is feeling stressed or relaxed.

[1738] A "server" is a computer system that receives, stores, analyzes user information and emotion information, and generates recipes.

[1739] A "natural language processing module" is a software module that analyzes input user information and extracts meaning from it.

[1740] An "emotion engine" is an algorithm or software that analyzes a user's facial recognition and voice data to identify the user's emotional state.

[1741] The "recipe generation algorithm" is an algorithm for generating an optimal recipe based on analyzed user information and emotional information.

[1742] A "natural language generation model" is an AI model that generates analysis results and recipes for users in natural-sounding sentences.

[1743] "Feedback" refers to response information such as user ratings and comments on the provided recipe.

[1744] "Machine learning algorithms" are algorithms used to optimize the performance of the system based on the feedback and sentiment information received.

[1745] This system provides original recipes by combining a user's preferences, dietary restrictions, allergy information, dietary history, and even emotional state. This system consists of a terminal used by the user, a server that supports it, and an emotion engine.

[1746] Hardware and software used

[1747] To realize this system, the following hardware and software are used:

[1748] Device: User device such as smartphone, tablet, or PC

[1749] Server: Cloud server or on-premise server

[1750] Database: Relational database such as MySQL or PostgreSQL

[1751] Natural language processing modules: Libraries such as SpaCy and NLTK

[1752] Emotion engine: facial recognition software, voice analysis tools

[1753] Recipe generation algorithms: Python scripts, algorithm libraries

[1754] Natural language generation models: AI models such as GPT-4

[1755] Machine learning algorithms: Libraries such as Scikit-Learn and TensorFlow

[1756] Program processing and specific examples

[1757] User: The user first launches the application and logs in. They enter profile information such as preferences, dietary restrictions, allergy information, and past eating history. For example, the user might enter, "My favorite ingredients are chicken and tomatoes, my least favorite ingredients are onions, and I'm allergic to nuts. I'd like a low-calorie diet." The application also reads the user's emotions through facial recognition and voice input, obtaining emotional information such as "I'm in a good mood today" or "I'm feeling stressed."

[1758] Device: The device sends the entered profile information and emotion information to the server. The data is sent in a common data format such as JSON.

[1759] Server: The server stores the received profile information and emotion information in a database. It assigns a unique ID to each user and organizes the profile information and emotion information.

[1760] Server: The profile information and sentiment information are then analyzed by a natural language processing module and sentiment engine, which identifies the user's preferences, allergies, dietary restrictions, and emotional state.

[1761] Server: Runs the recipe generation algorithm based on the analysis results. It searches the database for suitable recipes and customizes them for the user. For example, it might select a "low-calorie chicken and tomato recipe" or a "stress-relieving smoothie recipe."

[1762] Server: The selected recipes are converted into text using natural language generation AI (e.g., GPT-4), which then details the recipe steps, ingredient list, cooking time, and precautions.

[1763] Server: Sends the generated recipe data to the user's device.

[1764] Device: The device displays the submitted recipe in a visually friendly format, including the recipe title, ingredients list, cooking steps, cooking time, difficulty level, etc.

[1765] User: The user prepares ingredients based on the displayed recipe and begins cooking. While cooking, the user continues to follow the instructions while referring to the device.

[1766] Terminal: After cooking, the terminal displays a rating form to the user, providing a star rating (1-5 stars) and a comment input field, and also collecting emotional information.

[1767] User: Enter feedback. Example: Enter a comment such as "4 stars, it was delicious but I'd like to add a little spice," and send emotional information again.

[1768] Device: Sends rating and emotion information to the server. Feedback data is also sent in JSON format.

[1769] Server: The received feedback and emotional information are stored in a database and analyzed. Common comments and evaluation points are identified based on the feedback content and emotional information.

[1770] Server: The machine learning algorithm optimizes the recipe generation algorithm based on feedback information and sentiment information. This information is reflected in future recipe suggestions.

[1771] Prompt Sentence Examples

[1772] As a concrete example, consider a case where a user wants a recipe that is low in calories and has a stress-relieving effect. Here is an example prompt to input to the generative AI model:

[1773] User Preference Profile:

[1774] Favorite ingredients: chicken, tomatoes

[1775] Disliked food: Onions

[1776] Allergens: nuts

[1777] Dietary restrictions: Low calorie

[1778] Emotional state: Stressed

[1779] Please suggest a recipe that meets these criteria, including a specific ingredient list, cooking instructions, cooking time, and any warnings.

[1780] In this way, the system can provide customized recipes based on the user's preferences, dietary restrictions, allergy information, and even emotional state, and use that feedback to improve the system's accuracy.

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

[1782] Step 1:

[1783] User: A user launches an application and logs in.

[1784] Input: User ID, Password

[1785] Output: Login success or failure message

[1786] Specific operation: The user starts the application and enters their user ID and password on the login screen. When they press the "Login" button, the device sends the entered information to the server. The server compares it with the user information database and returns a message to the device indicating whether the login was successful. If a success message is displayed, the user can proceed to the next step.

[1787] Step 2:

[1788] User: Enters preferences, dietary restrictions, allergy information, past dietary history, and emotional state.

[1789] Input: food preferences, dietary restrictions, allergy information, past dietary information, emotional information

[1790] Output: Confirmation message for input contents

[1791] How it works: Users fill out a form in the application to enter their preferences, dietary restrictions, allergies, and dietary history, and provide their emotional state using facial recognition and voice input. When they press the "Send" button, the device sends this information to the server in JSON format.

[1792] Step 3:

[1793] Terminal: Sends the entered profile information and emotion information to the server.

[1794] Input: JSON format profile information, emotion information

[1795] Output: Message indicating that the data sent to the server has been sent successfully

[1796] Specific operation: JSON data containing profile information and emotion information is sent to the server via HTTPS. After sending, the device displays a message to the user indicating completion of sending.

[1797] Step 4:

[1798] Server: Stores the received data in a database.

[1799] Input: JSON format profile information, emotion information

[1800] Output: Database update completion message

[1801] Specific operation: The server parses the received JSON data and stores it in a relational database such as MySQL or PostgreSQL. A unique ID is assigned to each user data item and the data is properly organized. A completion message is generated when the database update is complete.

[1802] Step 5:

[1803] Server: Analyzes user information and emotional information using a natural language processing module and emotion engine.

[1804] Input: Profile information and emotion information stored in the database

[1805] Output: Analysis results (user preferences, allergies, dietary restrictions, emotional state)

[1806] How it works...

Claims

1. means for inputting the user's preferences, dietary restrictions, allergy information, and dietary history; means for transmitting the input information to a server; a means for storing the received user information in a database in the server; a means for analyzing user information by a natural language processing module in the server; a means for executing a recipe generation algorithm based on the analysis results to generate an optimal recipe for the user; means for transmitting the generated recipe to a user's terminal; a means for displaying the transmitted recipe on a user's terminal; means for transmitting user feedback to a server; means for storing and analyzing the received feedback in a database in the server; A means for optimizing the recipe generation algorithm based on the analysis results; A system including:

2. The system according to claim 1, further comprising means for generating a recipe taking into consideration the difficulty of the recipe, the time required, and the difficulty of obtaining ingredients.

3. The system according to claim 1 , further comprising means for analyzing the received feedback using a machine learning algorithm and reflecting the results in the next recipe generation.

Images