system

Abstract

We provide the system. [Solution] A means for collecting recipe information from a database of ingredient recipes, A means of analyzing collected recipe information and generating substitutes for each ingredient, A means of simulating new recipe combinations using the generated substitutes, A system that includes means for receiving specific requirements from users and presenting filtered and optimized recipes.

Description

Technical Field

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

Background Art

[0002] Patent Document 1 discloses a method for controlling a persona chatbot, which is performed by at least one processor, the method including: receiving a user utterance; adding the user utterance to a prompt including an instruction sentence related to an explanation of a character of the chatbot; 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

Summary of the Invention

Problems to be Solved by the Invention

[0004] In order to achieve sustainable food supply, such as stable supply of food, improvement of taste and quality with the increasing health consciousness, and addition of nutrition, diversification and individualization of recipes are required. However, recipe development requires specialized knowledge and skills, which are difficult for ordinary users to perform. Also, it is not easy to propose alternatives to address allergies and ingredient restrictions. There is a need to provide a system that solves these problems.

Means for Solving the Problems

[0005] The present invention solves the above problem with a system that includes means for collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating combinations of new recipes using the generated substitutes, and means for receiving specific requirements from a user and presenting filtered and optimized recipes. Specifically, the system divides and tags the collected recipe information using natural language processing and calculates the nutritional information of each ingredient by referring to a nutrition database. Furthermore, by using a text generation means that explains the generated substitute recipes in natural language, the system enables users to develop and optimize recipes efficiently and in a short period of time, even without specialized knowledge.

[0006] A "food ingredient recipe" is information that lists the ingredients for various foods and how to prepare them.

[0007] A "database" is an information management system that stores data according to certain rules and allows for the efficient retrieval and extraction of necessary information.

[0008] "Recipe information" refers to data that includes a list of ingredients, cooking instructions, nutritional information, and flavor characteristics.

[0009] "Means of collection" refers to mechanical or programmatic methods for automatically obtaining necessary information from the internet or databases.

[0010] "Means of analysis" refer to techniques and methods for breaking down and examining collected information, and for interpreting and extracting meaning according to the purpose.

[0011] A "substitute" refers to another ingredient that can be used in place of a particular ingredient and has similar nutritional value or taste characteristics.

[0012] "Means of generation" refers to methods and technologies for creating new data or information using programs.

[0013] A "simulation method" is a method for virtually modeling the actual cooking process and predicting and evaluating the optimal combination of recipes.

[0014] "Specific requirements" refer to conditions or constraints that users desire, such as allergy information or nutritional balance.

[0015] "Means of filtering and optimization" refer to techniques and methods for selecting data that meets specific conditions and further adjusting it to the most suitable state.

[0016] "Natural language processing" is the technology that enables computers to understand and process human language appropriately.

[0017] "Splitting and tagging" is the process of dividing information into smaller units and assigning labels or identification codes to each unit.

[0018] "Nutritional information" refers to data that shows how many calories, protein, fat, carbohydrates, and other nutrients a food or dish contains.

[0019] "To refer to" means to look at a specific source of information and obtain the necessary information.

[0020] "Text generation means" refers to technologies and methods that use algorithms or AI to automatically create text in a specific format. [Brief explanation of the drawing]

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

Modes for Carrying Out the Invention

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

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

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

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

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

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

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

[0029] [First Embodiment]

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

[0031] As shown in Figure 1, the data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

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

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

[0034] The reception device 38 is equipped with a touch panel 38A and a microphone 38B, etc., and receives user input. The touch panel 38A receives user input by detecting contact with an object (e.g., a pen or finger). The microphone 38B receives user input by detecting the user's voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0035] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form perceptible to the user 20 (e.g., audio and / or text). The display 40A displays visible information such as text and images according to instructions from the processor 46. The speaker 40B outputs audio according to instructions from the processor 46. The camera 42 is a small digital camera equipped with an optical system such as a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

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

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

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

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

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

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

[0042] The system of the present invention collects, analyzes, and optimizes food recipe information, and provides alternative recipes tailored to the user's requirements. Specific embodiments are described below.

[0043] System Configuration

[0044] This system is broadly composed of the following main components:

[0045] 1. Data Acquisition Module

[0046] 2. Data Analysis Module

[0047] 3. Alternative Recipe Generation Module

[0048] 4. User Interface Module

[0049] Program processing

[0050] Data Acquisition Module

[0051] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[0052] Data Analysis Module

[0053] The data collected by the server is analyzed using natural language processing (NLP). Specifically, the following steps are taken:

[0054] The recipe information is divided, and each ingredient is tagged as a separate item.

[0055] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[0056] The analysis results extract detailed information such as ingredient types, nutritional value, and allergen information. This makes it easier to generate alternative recipes in the next step.

[0057] Alternative recipe generation module

[0058] The server uses an AI model (e.g., a machine learning model) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination in the dish.

[0059] For example, if a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest a dairy-free alternative (for example, soy cream) and generate an optimal recipe using it.

[0060] User Interface Module

[0061] Users enter specific requirements (e.g., allergy information, requests for specific ingredients) via a chatbot. This input data is then sent to the server via the device.

[0062] The server searches the database based on the received requirements and filters the recipes accordingly. For example, in response to a request from a user with a dairy allergy, it searches for and displays recipes that do not use dairy products.

[0063] If a recipe is not found, the server uses an alternative recipe generation module to construct a new recipe and presents the optimized recipe to the user using a text generation module that explains it in natural language.

[0064] For example, if a user requests "I have an egg allergy, but I want pancakes without eggs," the device sends this request to the server, which then searches for and generates a suitable recipe. The generated recipe is then displayed to the user in a detailed explanation format.

[0065] This system allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge. The system aims to ensure a stable food supply and can meet the diverse needs of users.

[0066] The following describes the processing flow.

[0067] Step 1:

[0068] The server collects recipe information from recipe websites and ingredient databases on the internet. Specifically, it uses scraping tools to obtain recipe titles, ingredients, cooking instructions, and nutritional information, and stores them in a database.

[0069] Step 2:

[0070] The server analyzes the collected recipe information. Natural language processing (NLP) is used to split and tag the ingredient list and cooking instructions for each recipe. For example, the ingredient "milk" is classified as "dairy products".

[0071] Step 3:

[0072] The server references a nutrition database and calculates nutritional information such as calories, protein, fat, and carbohydrates for each ingredient. Based on this information, it calculates the total nutritional value of each recipe.

[0073] Step 4:

[0074] The server uses an AI model to generate substitutes for each ingredient. For example, it creates a specific list of alternatives, such as suggesting soy milk instead of cow's milk.

[0075] Step 5:

[0076] The server simulates new recipe combinations using the generated substitutes. The simulation considers factors such as the balance of flavors, nutritional value, and allergen elimination. For example, it evaluates variations that use cashew cream instead of regular cream.

[0077] Step 6:

[0078] The user uses the chatbot function to enter specific requirements. For example, they might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[0079] Step 7:

[0080] The device analyzes the user's requirements and extracts specific conditions (e.g., "dairy allergy," "cream," "pasta"). The extracted results are then sent to the server.

[0081] Step 8:

[0082] The server filters the database based on the user's requirements and searches for relevant recipes. For example, it might search for pasta recipes that use cream without dairy products.

[0083] Step 9:

[0084] If a matching recipe is not found, the server will use an alternative recipe generation module to create a new alternative recipe. For example, it might generate a pasta recipe where cream is replaced with soy cream.

[0085] Step 10:

[0086] The server uses a text generation module to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might display, "This recipe uses soy cream instead of regular cream."

[0087] Step 11:

[0088] The device receives the best alternative recipe from the server and presents it to the user. The user can then review the presented recipe and learn about the specific cooking steps and ingredient list.

[0089] (Example 1)

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

[0091] Conventional food recipe systems have struggled to easily generate and optimize alternative recipes to meet specific user requirements. Furthermore, manual recipe collection and analysis are time-consuming, preventing users from quickly obtaining their desired alternative recipes. Additionally, recipe generation that considers the nutritional and allergen information of individual ingredients is insufficient.

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

[0093] In this invention, the server includes means for collecting recipe information from multiple websites that provide recipe information via a communication network; means for analyzing the collected recipe information using natural language processing technology and tagging each ingredient as an independent item; means for referring to a nutrition database and calculating nutritional information for each ingredient; means for generating substitutes for each ingredient using a machine learning model; means for simulating new recipes using the generated substitutes; and means for receiving specific requirements via a user terminal and presenting filtered and optimized recipes. This makes it possible to provide alternative recipes that quickly and appropriately respond to the user's specific requirements.

[0094] A "communication network" is a collection of technical means and protocols used to exchange data, and refers to wide-area communication systems, including the Internet.

[0095] "Recipe information" refers to data containing detailed information about how to prepare a dish, including a specific list of ingredients, cooking steps, and nutritional information.

[0096] A "website" refers to a collection of online pages that provide information accessible via the internet.

[0097] "Natural language processing technology" refers to the technology that enables computers to understand, analyze, generate, and respond to human language, including tasks such as text segmentation, tagging, and semantic understanding.

[0098] "Tagging" is the process of classifying data into specific categories or attributes and adding annotations or labels to make it identifiable.

[0099] A "nutrition database" is a database that collects information on the nutritional components of food, including data on nutrients such as energy, vitamins, and minerals for each food item.

[0100] A "machine learning model" is a type of artificial intelligence that learns patterns based on data and performs tasks such as prediction, classification, and generation.

[0101] A "substitute" is an ingredient used in place of the original ingredient, and is selected to have similar nutritional value and taste characteristics.

[0102] A "simulation" is a trial or test conducted under a virtual environment or conditions, a process of observing the results by imitating a real-world situation.

[0103] A "user terminal" refers to a device that a user directly operates, and includes personal computers, smartphones, tablets, and other similar devices.

[0104] "Requirements" refer to requests or preferences submitted by users based on specific conditions or desires, and include specific needs such as allergy information or the use of certain ingredients.

[0105] "Filtering" refers to the process of selecting data based on specific criteria and extracting relevant information.

[0106] "Optimization" refers to adjusting a system or process to achieve the best results under specific goals and constraints.

[0107] This invention is a system for users to quickly and effectively generate and provide alternative recipes based on specific requirements. This system mainly consists of a server, user terminals, and a database connected via a communication network.

[0108] System Configuration

[0109] The server is connected to the internet and is responsible for collecting recipe information from multiple recipe websites. Specifically, it uses the Python requests library to access specified websites and uses BeautifulSoup to scrape the necessary information (ingredients list, cooking instructions, nutritional information) from the web pages. The collected data is stored in JSON format or in relational databases such as MySQL® or PostgreSQL.

[0110] Specific example: The server regularly collects ingredient lists, cooking instructions, and nutritional information from AllRecipes and Cookpad, and stores them in a database, ensuring that the latest recipe information is always updated.

[0111] Furthermore, the server also plays a role in analyzing the collected recipe information using natural language processing (NLP) techniques. Specifically, it uses Python NLP libraries (such as NLTK and SpaCy) to analyze the recipe text and tag each ingredient as a separate item. It also refers to nutrition databases (e.g., the USDA Food Database) to calculate the nutritional information for each ingredient.

[0112] Specific example: If a recipe includes "tomatoes, onions, and garlic," tags such as "vegetable" and "spice" will be assigned to each ingredient, and nutritional information will be calculated.

[0113] In the next stage, the server uses a machine learning model (e.g., Scikit-learn's RandomForestClassifier) ​​to generate substitutes for each ingredient from the collected data. In this process, ingredients with similar nutritional value and flavor characteristics are suggested. New recipes using the generated substitutes are then simulated by the AI ​​model. The simulation results are optimized, taking into account factors such as the balance of flavors, nutritional value, and allergen elimination.

[0114] Specific example: If a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest soy milk cream as an alternative and provide an optimal recipe using it.

[0115] Through the user's terminal, the user enters specific requirements (for example, allergy information or a desire to use specific ingredients) into the chatbot. The terminal sends these requirements to the server, which searches the database based on the received requirements. If a suitable recipe is not found, the server uses an alternative recipe generation module to construct a new recipe and provides the user with recipe information optimized for them.

[0116] Specific example: If a user requests "I have an egg allergy, but I want pancakes without eggs," that requirement is sent from the device to the server. The server searches for and generates a suitable recipe and presents it to the user.

[0117] Example of a prompt

[0118] Data collection prompt: "Collect recipe information, including ingredient lists, cooking instructions, and nutritional information, from recipe websites on the internet and save it in JSON format."

[0119] Data analysis prompt: "Analyze the collected recipe data, tag each ingredient, calculate nutritional information, and save it in JSON format."

[0120] Prompt for generating alternative recipes: "Use an AI model to generate dairy-free pasta recipes for users with dairy allergies."

[0121] User interface prompt: "Based on the user's requirements (e.g., egg allergy), please provide and display the appropriate alternative recipe in a detailed format."

[0122] Through the above means, it becomes possible to provide a system that allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge.

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

[0124] Step 1: Data Collection

[0125] The server connects to the internet and accesses multiple recipe websites. This connection uses the Python requests library to send HTTP requests. The server retrieves HTML documents from each website. Specifically, it accesses web pages using the requests.get(URL) method and retrieves the HTML data received as a response.

[0126] Input: URLs of multiple specified recipe websites.

[0127] Output: HTML document corresponding to each URL.

[0128] Step 2: Web scraping

[0129] The server uses BeautifulSoup to parse and extract HTML documents. Specifically, it uses `soup = BeautifulSoup(html, 'html.parser')` to extract the ingredient list, cooking instructions, and nutritional information for each recipe.

[0130] Input: The HTML document obtained in Step 1.

[0131] Output: Data including recipe ingredient list, cooking instructions, and nutritional information.

[0132] Step 3: Save Data

[0133] The server saves the extracted recipe data in JSON format or a relational database. For example, it connects to a MySQL database and executes an SQL query like INSERT INTO recipes (title, ingredients, instructions, nutrition) VALUES (...).

[0134] Input: Recipe data extracted in Step 2.

[0135] Output: Recipe information stored in a JSON file or database.

[0136] Step 4: Natural Language Processing (NLP)

[0137] The server analyzes the collected and stored recipe data using a Python NLP library (e.g., NLTK or SpaCy). Specifically, it splits the recipe text and tags each ingredient as an independent item. The library is loaded like this: nlp = spacy.load('en_core_web_sm') and the analysis is performed with doc = nlp(recipe_text).

[0138] Input: Recipe text retrieved from the database.

[0139] Output: Data for each tagged material.

[0140] Step 5: Calculate nutritional information

[0141] The server references a nutrition database (e.g., the USDA Food Database) and calculates the nutritional information for each tagged ingredient. Specifically, it calculates the energy, vitamins, minerals, etc. values ​​for each ingredient and sets it up as follows: `nutrition_info = calculate_nutrition(ingredient)`.

[0142] Input: Material data tagged in Step 4.

[0143] Output: Recipe data with added nutritional information.

[0144] Step 6: Generating a substitute for the material

[0145] The server uses a machine learning model (for example, Scikit-learn's RandomForestClassifier) ​​to generate substitutes for each ingredient. For example, it might substitute "dairy products" with "soy cream." Substitutes are suggested using a method like model.predict(alternative_ingredient).

[0146] Input: Recipe data with nutritional information added in Step 5.

[0147] Output: List of materials for which alternatives have been suggested.

[0148] Step 7: Simulation of alternative recipes

[0149] The server simulates a new recipe using the generated substitute ingredients. The simulation uses an AI model that considers factors such as flavor balance, nutritional value, and allergen elimination. The simulation is executed using a command like `simulate_recipe(new_ingredients)`.

[0150] Input: The list of alternatives suggested in Step 6.

[0151] Output: A simulated new recipe.

[0152] Step 8: Enter user requirements

[0153] The user enters specific requirements into the chatbot via their device. For example, they might type, "I have an egg allergy, so I'd like egg-free pancakes."

[0154] Input: User requirements (e.g., allergy information).

[0155] Output: Requirements data from the terminal to the server.

[0156] Step 9: Submitting Requirements

[0157] The terminal sends user requirements to the server. The requirements data is delivered to the server via network communication.

[0158] Input: User requirements entered in Step 8.

[0159] Output: Requirements data sent to the server.

[0160] Step 10: Search and display recipes

[0161] The server searches the database for a recipe that matches the user's requirements. If no suitable recipe is found, it uses an alternative recipe generation module to create a new recipe. It then generates optimized recipe information.

[0162] Input: Requirements data sent to the server.

[0163] Output: A recipe that meets the user requirements, or an alternative recipe that has been generated.

[0164] Step 11: Providing information to users

[0165] The terminal displays recipe information received from the server to the user. A GUI (Graphical User Interface) is used for this purpose.

[0166] Input: Recipe information sent from the server.

[0167] Output: Recipe information displayed on the terminal.

[0168] (Application Example 1)

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

[0170] Modern food delivery services struggle to accommodate the diverse needs of users, particularly allergies and dietary preferences. Users have difficulty finding ingredients and recipes that suit their health and tastes, and as a result, obtaining suitable alternative recipes requires considerable time and effort. Furthermore, there are limited means of quickly ordering meals based on these alternative recipes. Thus, current food delivery systems face the challenge of not being able to fully meet the specific needs of users.

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

[0172] In this invention, the server includes means for collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes, means for receiving specific requirements from the user and presenting filtered and optimized recipes, means for collecting and storing the user's allergy information and food preferences, and means for enabling the ordering of dishes based on the alternative recipes based on the collected user information. As a result, the user can not only quickly obtain alternative recipes that suit their preferences and health condition, but also immediately order dishes through a food delivery service based on the generated alternative recipes.

[0173] A "food ingredient recipe database" is a collection of data containing multiple recipes stored on the internet or in dedicated databases.

[0174] "Recipe information" refers to detailed information about each recipe, such as the ingredient list, cooking instructions, and nutritional information.

[0175] A "substitute" refers to an alternative ingredient used to replace an ingredient in the original recipe, based on the specific requirements of a particular user.

[0176] "Simulation" is the process of experimenting with new recipes using the generated substitutes.

[0177] "Specific requirements" refer to individual conditions such as allergy information, food preferences, and nutritional requirements that users possess.

[0178] "Filtering" is the process of selecting recipe information or alternative recipes that meet specific requirements.

[0179] "Optimization" is the process of adjustment and improvement to extract and propose the recipe that best suits specific requirements.

[0180] A "user" refers to an individual or group that uses the system to obtain alternative recipes and then orders dishes based on those recipes.

[0181] "Allergy information" refers to information about foods that a user may be allergic to.

[0182] "Food preferences" refers to information about a user's preferences regarding food ingredients they particularly want to use or avoid.

[0183] An "order" is the act of a user requesting the purchase and delivery of a dish generated based on an alternative recipe.

[0184] A "server" refers to a computer system that collects, analyzes, optimizes, and provides recipe information.

[0185] The program for the system that realizes this invention is described in detail below.

[0186] System configuration and operation

[0187] This system primarily consists of three components: a server, a terminal, and a user. The server plays the main role of collecting and analyzing recipe information, generating alternative recipes, and providing information to users. The terminal is the interface where users input information and mediates communication with the server. The user is the entity that inputs specific conditions and selects and orders optimized alternative recipes.

[0188] 1. Server operation:

[0189] The server operates using the following procedure.

[0190] Recipe information is collected from a database of food ingredient recipes. The collected recipe information includes ingredient lists, cooking instructions, and nutritional information.

[0191] The collected recipe information is segmented and tagged using natural language processing (NLP), and the nutritional information for each ingredient is calculated by referring to a nutrition database.

[0192] Using an AI model, we generate alternative ingredients based on specific conditions and simulate new recipe combinations.

[0193] The system receives specific requirements from users (e.g., allergy information, food preferences) and presents filtered and optimized recipes.

[0194] Based on the collected user information, it will be possible to order dishes based on alternative recipes.

[0195] 2. Device operation:

[0196] Users input allergy information and food preferences via their devices. This information is sent to the server in JSON format.

[0197] 3. User Interface:

[0198] Users can receive alternative recipe suggestions by entering specific requirements using a terminal. For example, they might enter a specific requirement such as, "I have a dairy allergy, so I would like pasta without cream." The server then suggests alternative ingredients and presents an optimized recipe. Users can review the suggested recipe and order a meal based on it.

[0199] Hardware and software to be used

[0200] Server: Collects and analyzes recipe information, generates alternative recipes, and provides information. The server runs natural language processing models, a nutrition database, and AI models.

[0201] Device: A smartphone or tablet device used by the user, providing the user interface. The food delivery application is installed on it.

[0202] Examples of specific cases and prompt statements

[0203] For example, if a user has a dairy allergy and wants a vegan diet, they would enter the following through their device:

[0204] "I have a dairy allergy and would like a vegan diet. Please suggest pasta recipes that do not use cream."

[0205] This prompt is used by the server to generate alternative recipes in response to the user's request and suggest a specific recipe that is suitable for the user.

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

[0207] Step 1:

[0208] The user uses a terminal to input allergy information and food preferences. This information is sent to the server in JSON format. The input data includes specific allergy information (e.g., dairy allergy) and preferences (e.g., vegan). The server receives this data and stores it in its internal database.

[0209] Step 2:

[0210] The server collects recipe information from a database of food ingredient recipes. Specifically, it uses recipe websites on the internet and food ingredient database APIs to obtain recipe data including ingredient lists, cooking instructions, and nutritional information. This data is stored in JSON format or a relational database (e.g., MySQL).

[0211] Step 3:

[0212] The server collects recipe information and uses natural language processing (NLP) to segment and tag it. Each recipe's ingredients are classified as a separate item and tagged accordingly. The input data is the recipe information, and the output data is a list of tagged ingredients. During this process, NLP libraries (e.g., NLTK, spaCy) are used to analyze the data.

[0213] Step 4:

[0214] The server references a nutrition database and calculates the nutritional information for each ingredient. Based on a tagged list of ingredients, it retrieves the corresponding nutritional information from the nutrition database (e.g., USDA nutrition database) and adds the calculation results. The input data is the ingredient list, and the output data is the ingredient list with the nutritional information added.

[0215] Step 5:

[0216] The server uses an AI model to generate substitutes for each ingredient. Based on the user's specific requirements (e.g., dairy allergy, vegan), the AI ​​model (e.g., machine learning model, transformer) suggests appropriate substitute ingredients. The input data is a list of ingredients with nutritional information, and the output data is a list of substitute ingredients.

[0217] Step 6:

[0218] The server simulates new recipe combinations using substitute ingredients. Based on an AI model, it generates new recipes considering the balance of flavors and nutritional value of the dishes. The input data is a list of substitute ingredients, and the output data is the new recipe.

[0219] Step 7:

[0220] The system filters specific requirements entered by the user via their device and presents optimized recipes. The server searches for recipes that match the user's requirements and extracts the relevant recipes. The input data is the user's requirements, and the output data is the optimized recipe.

[0221] Step 8:

[0222] Based on user information collected by the server, it enables ordering of dishes based on alternative recipes. Users can view alternative recipes on their terminals and, if they like them, proceed directly to the order screen. Input data is the user's order request, and output data is order confirmation information.

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

[0224] This invention proposes a system for collecting, analyzing, and optimizing food recipe information, and providing alternative recipes tailored to the user's requirements and preferences. Specific embodiments thereof are described below.

[0225] System Configuration

[0226] This system is broadly composed of the following main components:

[0227] 1. Data Acquisition Module

[0228] 2. Data Analysis Module

[0229] 3. Alternative Recipe Generation Module

[0230] 4. Emotional Engine

[0231] 5. User Interface Module

[0232] Program processing

[0233] Data Acquisition Module

[0234] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[0235] Data Analysis Module

[0236] The data collected by the server is analyzed using natural language processing (NLP). Specifically, the following steps are taken:

[0237] The recipe information is divided, and each ingredient is tagged as a separate item.

[0238] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[0239] The analysis results extract detailed information such as ingredient types, nutritional value, and allergen information. This makes it easier to generate alternative recipes in the next step.

[0240] Alternative recipe generation module

[0241] The server uses an AI model (e.g., a machine learning model) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination in the dish.

[0242] For example, if a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest a dairy-free alternative (for example, soy cream) and generate an optimal recipe using it.

[0243] Emotional Engine

[0244] The emotion engine recognizes the user's emotions. This emotion engine analyzes the user's emotional state (e.g., joy, sadness, stress) using text input, voice, and facial recognition technology.

[0245] The recognized emotional information is reflected in the recipe suggestions. For example, if the user is feeling stressed, the system will suggest recipes using ingredients that have a relaxing effect.

[0246] User Interface Module

[0247] Users enter specific requirements (e.g., allergy information, requests for specific ingredients) via a chatbot. This input data is sent to the server through the device. For example, a user might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[0248] The emotion engine analyzes the user's input, facial expressions, and tone of voice to recognize the user's current emotional state. This emotional information is sent to the server and incorporated into the recipe recommendation process.

[0249] The server searches the database and filters the recipes based on the received requirements and emotional information. For example, when searching for pasta recipes using cream without dairy products, if the user is feeling down, it prioritizes displaying recipes that include ingredients that can lift their mood.

[0250] For example, if a user requests egg-free pancakes despite having an egg allergy, and the emotion engine simultaneously detects stress, the device sends this requirement and emotional information to the server. The server searches for and generates a suitable recipe, suggesting an optimized recipe that includes ingredients with relaxing effects (e.g., vanilla extract).

[0251] A text generation module is used to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might say, "This recipe uses banana puree instead of eggs and also includes vanilla extract for a relaxing effect."

[0252] This system allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge. Furthermore, it enables recipe suggestions tailored to the user's emotional state, providing more personalized support.

[0253] The following describes the processing flow.

[0254] Step 1:

[0255] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe, and this data is stored in the database.

[0256] Step 2:

[0257] The server analyzes the collected recipe information using natural language processing (NLP). Specifically, the recipe information is divided, and each ingredient is tagged as an independent item. For example, the ingredient "milk" is classified as "dairy products."

[0258] Step 3:

[0259] The server references a nutrition database and calculates the nutritional information for each ingredient. Specifically, it retrieves information such as calories, protein, fat, and carbohydrates for each ingredient and calculates the total nutritional value for each recipe.

[0260] Step 4:

[0261] The server uses an AI model to generate substitutes for each ingredient. For example, it suggests "soy milk" for "milk." It also lists alternative candidates for other ingredients and provides substitutes that meet the user's needs.

[0262] Step 5:

[0263] The server simulates new recipe combinations using the generated substitutes. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination. For example, it evaluates variations that use cashew cream instead of regular cream.

[0264] Step 6:

[0265] The user uses the chatbot function to enter specific requirements. For example, they might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[0266] Step 7:

[0267] The terminal analyzes the user's requirements and extracts specific conditions. The extracted conditions (e.g., "dairy allergy," "cream," "pasta") are then sent to the server.

[0268] Step 8:

[0269] The emotion engine recognizes the user's emotions. This involves a process of analyzing the user's emotional state (e.g., joy, sadness, stress) using text input, voice, and facial recognition technology.

[0270] Step 9:

[0271] The server filters the database based on user requirements and emotional information to find relevant recipes. For example, if searching for pasta recipes using cream without dairy products, and the user is feeling stressed, the server will prioritize displaying recipes that use ingredients with relaxing properties.

[0272] Step 10:

[0273] If a matching recipe is not found, the server uses an alternative recipe generation module to create a new alternative recipe. For example, it might generate a pasta recipe where cream is replaced with soy cream.

[0274] Step 11:

[0275] The server uses a text generation module to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might display: "This recipe uses soy cream instead of regular cream."

[0276] Step 12:

[0277] The device receives the best alternative recipe from the server and presents it to the user. The user can then review the presented recipe and learn about the specific cooking steps and ingredient list.

[0278] Step 13:

[0279] When the user selects a proposed recipe, steps are also provided to offer additional cooking advice and customization options. In this way, the user can easily obtain and execute the optimal alternative recipe.

[0280] (Example 2)

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

[0282] In a conventional food recipe providing system, it is difficult to propose recipes considering specific requirements and emotional states of users. As a result, recipes that do not match the user's preferences and emotions may be provided, and there is a problem of decreased satisfaction. Also, due to insufficient detailed data analysis regarding nutritional information and ingredient substitutes, it is difficult to propose alternative recipes considering health aspects and allergies.

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

[0284] In this invention, the server includes means for collecting recipe information from a database of food ingredient recipes, means for analyzing the collected recipe information using natural language processing to generate substitutes for each ingredient, means for simulating combinations of new recipes using the generated substitutes using a machine learning model, and means for receiving specific requirements and emotional states from the user, analyzing the emotional information using an emotion analysis engine, and presenting filtered and optimized recipes. Thereby, it becomes possible to optimize recipes according to specific requirements and emotional states of the user and to propose alternative recipes considering health aspects and allergies.

[0285] A "food ingredient recipe" describes information on ingredients and their cooking methods.

[0286] A "database" is a system for systematically managing and searching a large amount of data.

[0287] "Recipe information" includes instructions on cooking, ingredients to be used, cooking procedures, nutritional information, etc.

[0288] "Natural language processing" is a technology that enables a computer to understand human language and perform analysis and generation.

[0289] "Analysis" is a process of examining the collected data in detail to understand its meaning and patterns.

[0290] "Substitute" is another material used to replace a specific material.

[0291] "Machine learning model" is an algorithm that learns patterns from a series of data and performs prediction and classification on new data.

[0292] "Simulation" is a process of imitating actual operations by virtually reproducing real-world processes and systems.

[0293] "Specific requirements" of the "user" refer to the specific desires and conditions that the user has for the recipe.

[0294] "Sentiment analysis engine" is a technology that analyzes user input data (text, voice, image) to recognize the user's emotional state.

[0295] "Filtering" is a process of selecting data based on specific criteria.

[0296] "Optimization" is a process of making adjustments to obtain the best results under specific conditions and constraints.

[0297] The present invention is a system that collects, analyzes, and optimizes food recipe information and provides alternative recipes according to user requirements and emotions. This system is mainly composed of the following major components.

[0298] 1. Data Collection Module

[0299] 2. Data Analysis Module

[0300] 3. Alternative Recipe Generation Module

[0301] 4. Emotion Engine

[0302] 5. User Interface Module

[0303] System Configuration

[0304] Data Collection Module

[0305] The server collects recipe information from recipe websites on the Internet and ingredient databases. Specifically, web scraping is performed using libraries such as Python's BeautifulSoup and Scrapy to collect the ingredient list, cooking procedures, and nutritional information of each recipe. The collected data is stored in JSON format or a relational database (e.g., MySQL or PostgreSQL).

[0306] Data Analysis Module

[0307] The server analyzes the collected data using natural language processing (NLP). At this stage, NLP libraries (e.g., spaCy or NLTK) are used to tokenize the recipe information and extract important keywords and ingredients. Also, a nutritional database (e.g., USDA Nutrient Database) is referenced to calculate the nutritional information of each ingredient.

[0308] Alternative Recipe Generation Module

[0309] The server uses machine learning models (e.g., models built using TENSORFLOW® or PyTorch) to generate alternative recipes based on user requirements and sentiment information. This includes the ability to suggest and simulate alternative ingredients. For example, if a user with a dairy allergy wants to make a pasta dish that uses cream, the server will suggest a dairy-free alternative (e.g., soy cream) and generate an optimal recipe using it.

[0310] Emotional Engine

[0311] An emotion engine recognizes the user's emotions. This is a technology that analyzes the user's text input, voice, and image data to recognize their emotional state (e.g., joy, sadness, stress). Examples include using Google® Cloud Vision API or IBM Watson® Tone Analyzer.

[0312] User Interface Module

[0313] Users input specific requirements (e.g., allergy information, desired ingredients) via a chatbot. This input data is sent to the server through the device. Based on the received requirements and sentiment information, the server searches its database and filters for suitable recipes. The generated recipes are explained in natural language and presented to the user in an easy-to-understand format.

[0314] Examples of prompt statements

[0315] "I have a dairy allergy, but I'd like a pasta recipe that uses cream. I'm feeling a bit down today, so please let me know if you have any recipes that will cheer me up."

[0316] Examples

[0317] When a user enters a prompt into the chatbot, the device sends that input data to the server. The server first analyzes the recipe information collected by the data collection module using the data analysis module, and then recognizes the sentiment information using the sentiment engine. Subsequently, the alternative recipe generation module generates the optimal alternative recipe based on the user's requirements and sentiment. The generated recipe is then provided to the user via the user interface module. Through this series of processes, the user can efficiently obtain the optimal recipe that suits their requirements and sentiment.

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

[0319] Step 1: Data Collection

[0320] The server collects recipe information from multiple recipe websites and ingredient databases on the internet. This is done using web scraping libraries such as Python's BeautifulSoup and Scrapy.

[0321] Input: URL of the recipe website or API endpoint.

[0322] Data processing: The server retrieves HTML data from the web page and extracts the necessary information (e.g., ingredient list, cooking instructions, nutritional information, etc.).

[0323] Output: Recipe information stored in JSON format or a relational database.

[0324] Step 2: Data Analysis

[0325] The server analyzes the collected data using natural language processing (NLP). Specifically, recipe information is tokenized using an NLP library (e.g., spaCy, NLTK), and important keywords and tags are extracted.

[0326] Input: Recipe information saved in JSON format.

[0327] Data processing: The server tokenizes the ingredient list and tags each ingredient as an independent item. It also references a nutrition database (e.g., USDA Nutrient Database) to calculate the nutritional information for each ingredient.

[0328] Output: Data including analyzed recipe information, nutritional value, allergen information, etc.

[0329] Step 3: Emotion Analysis

[0330] The device acquires user input (text, voice, images) into the chatbot and sends it to the emotion engine. The emotion engine analyzes this data to recognize the user's emotional state.

[0331] Input: Text, audio, and image data from the user.

[0332] Data Processing: The emotion engine performs emotion analysis using NLP, facial recognition, and speech analysis technologies (e.g., Google Cloud Vision API and IBM Watson Tone Analyzer).

[0333] Output: User's emotional state (e.g., joy, sadness, stress).

[0334] Step 4: Generate alternative recipes

[0335] The server uses machine learning models (e.g., TensorFlow or PyTorch) to generate alternative recipes based on user requirements and sentiment information.

[0336] Input: Analyzed recipe information, nutritional data, user requirements, and emotional state.

[0337] Data Processing: The server considers user requirements and emotional information, suggesting alternative ingredients that are similar in nutritional value, allergen elimination, and taste characteristics. Machine learning models are used in this process to select the optimal ingredients.

[0338] Output: Optimized recipe using substitutes.

[0339] Step 5: Recipe suggestion

[0340] The server provides the generated alternative recipe to the user in an understandable format using a text generation module (e.g., natural language generation technology).

[0341] Input: Information on alternative recipes.

[0342] Data processing: The server generates recipe descriptions using natural language generation technology.

[0343] Output: The recipe description presented to the user.

[0344] Step 6: Presentation to the user

[0345] The device presents the generated recipe to the user.

[0346] Input: Recipe description sent from the server.

[0347] Data processing: The process by which the terminal formats recipe information and displays it in the user interface.

[0348] Output: The specific alternative recipe displayed on the user's screen.

[0349] Through these processing steps, users can efficiently obtain the optimal alternative recipe tailored to their requirements and emotional state.

[0350] (Application Example 2)

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

[0352] While modern food recipe systems can accommodate specific user requirements such as allergies and dietary restrictions, systems that offer personalized recipe suggestions based on a user's emotional state still do not exist. In particular, meal suggestions that take into account emotions such as stress and joy are lacking, making it difficult to enhance users' psychological and emotional satisfaction. Furthermore, there are limitations to generating optimized alternative recipes, posing a challenge in quickly responding to diverse user needs.

[0353] The specific processing performed by the specific 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 collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes, means for recognizing the user's emotions and making recipe suggestions based on them, and means for inputting emotions and requirements through a user interface and providing optimized recipes. This makes it possible to provide optimized alternative recipes that correspond to the user's specific requirements and emotional state.

[0354] A "food recipe database" is a digital structure for systematically storing and managing food recipe information.

[0355] "Recipe information" refers to a dataset containing detailed information such as ingredient lists, cooking instructions, and nutritional information.

[0356] A "food substitute" is an ingredient that can be used in place of a specific ingredient and has similar nutritional value or taste characteristics.

[0357] A "simulation" is the process of using data and algorithms to mimic real-world situations and predict outcomes under hypothetical conditions.

[0358] "Specific user requirements" refer to detailed conditions desired by individual users, such as allergy information, food preferences, and nutritional needs.

[0359] "Filtering" is the process of selecting data that meets specific criteria from a large amount of data.

[0360] An "optimized recipe" is a recipe that has been tailored to the user's specific requirements and emotional state to be the most suitable for them.

[0361] "Means of recognizing emotions" refers to technologies and software used to analyze and identify a user's emotional state.

[0362] A "user interface" is an interactive environment for input and output that allows a user to interact with a system.

[0363] "Means of collection" refers to the functions and methods for obtaining recipe information from databases or the internet.

[0364] "Means of analysis" refers to the process of analyzing collected data and extracting meaningful information.

[0365] "Means of generating substitutes" refer to methods or algorithms for suggesting ingredients that can be used as substitutes for specific ingredients.

[0366] "Means of presentation" refers to methods and technologies for displaying user-optimized recipe information in an easy-to-understand format.

[0367] This invention is implemented as a system that provides food delivery services that respond to the specific requirements and emotional states of users. Specific embodiments of this system are described below.

[0368] System Configuration

[0369] This system includes the following main components.

[0370] 1. Data Acquisition Module

[0371] 2. Data Analysis Module

[0372] 3. Alternative Recipe Generation Module

[0373] 4. Emotion Recognition Engine

[0374] 5. User Interface Module

[0375] Data Acquisition Module

[0376] The server collects recipe information from online recipe and ingredient databases. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[0377] Data Analysis Module

[0378] The server analyzes the collected data using natural language processing (NLP). Specifically, it follows these steps:

[0379] The recipe information is divided, and each ingredient is tagged as a separate item.

[0380] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[0381] The analysis results extract detailed information such as the type of material, nutritional value, and allergen information.

[0382] Alternative recipe generation module

[0383] The server uses AI models (e.g., machine learning models) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This generates alternative recipes that are best suited to the user's specific requirements.

[0384] Emotion recognition engine

[0385] The emotion recognition engine recognizes the user's emotions using text input, voice, and facial recognition technology. The analyzed emotion information is then reflected in recipe suggestions. For example, if the user is feeling stressed, the engine will suggest recipes using ingredients that have a relaxing effect.

[0386] User Interface Module

[0387] The user enters specific requirements (e.g., allergy information, preference for certain ingredients) through the user interface. This input data is then sent to the server via the terminal.

[0388] For example, if a user enters "I have an egg allergy, but I want pancakes that don't use eggs," and the emotion recognition engine detects stress, the following prompt message will be generated.

[0389] Generate a recipe that meets the following requirements: Without eggs suitable for someone feeling stressed.

[0390] Sending this prompt to the server's AI model generates an optimized pancake recipe that includes vanilla extract, which has stress-reducing effects.

[0391] Examples

[0392] For example, if a user enters a request stating, "I have a dairy allergy, but I want to eat pasta with cream," the emotion recognition engine will recognize the user's emotional state and suggest a dairy-free alternative (e.g., soy cream). Furthermore, a recipe including ingredients that can improve the user's mood will be generated, tailored to their emotional state.

[0393] This allows users to quickly find the perfect meal tailored to their emotional state and specific requirements. The system can improve user satisfaction and provide a personalized food delivery service.

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

[0395] Step 1:

[0396] The server collects recipe information from recipe and ingredient databases on the internet. It uses HTTP requests to retrieve data from APIs and saves the retrieved data in JSON format. The input is the API URL, and the output is recipe data in JSON format.

[0397] Step 2:

[0398] The server analyzes the collected recipe data using a natural language processing (NLP) library. This process divides the recipe information and tags each ingredient as an independent item. It also refers to a nutrition database and calculates the nutritional information for each ingredient. The input is recipe data in JSON format, and the output is the analyzed recipe data and nutritional information.

[0399] Step 3:

[0400] The server receives specific requirements and sentiment information entered by the user. It collects requirements entered by the user through the user interface and sentiment information recognized by the sentiment recognition engine. The input consists of the user's requirements and sentiment information, while the output consists of the received requirements and sentiment information.

[0401] Step 4:

[0402] The emotion recognition engine analyzes user input text and voice to recognize the user's emotional state. Specifically, it uses speech recognition software and facial recognition technology to evaluate the user's emotions. The input is the user's text and voice data, and the output is the recognized emotion information.

[0403] Step 5:

[0404] The server uses an AI model to generate alternative recipes based on analyzed recipe data, user requirements, and sentiment information. This process generates the optimal recipe by combining alternative ingredients that meet the user's requirements (e.g., allergy information). The input is the analyzed recipe data, user requirements, and sentiment information, and the output is the generated alternative recipe.

[0405] Step 6:

[0406] The server filters and optimizes the generated alternative recipes. During this process, it selects the optimal recipe, taking into account factors such as the nutritional value of the ingredients used and the user's emotional state. The input is the generated alternative recipe, and the output is the optimized, best-in-class recipe.

[0407] Step 7:

[0408] The user interface presents optimized recipe information to the user. A text generation module is used to generate detailed recipe descriptions for easy viewing. The input is optimized recipe information, and the output is a text-based recipe description for display to the user.

[0409] As a concrete example of its operation, if a user enters a request such as "I have an egg allergy, but I would like pancakes that do not contain eggs," and the emotion recognition engine detects stress, the following prompt message will be generated.

[0410] Generate a recipe that meets the following requirements: Without eggs suitable for someone feeling stressed.

[0411] By sending this prompt to the AI ​​model, an optimized pancake recipe containing vanilla extract, known for its stress-reducing effects, is generated. Finally, the user is shown through the user interface the message, "This recipe uses banana puree instead of eggs and also includes relaxing vanilla extract."

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

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

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

[0415] [Second Embodiment]

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

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

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

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

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

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

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

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

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

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

[0426] In the smart glasses 214, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

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

[0428] The system of the present invention collects, analyzes, and optimizes food recipe information, and provides alternative recipes tailored to the user's requirements. Specific embodiments are described below.

[0429] System Configuration

[0430] This system is broadly composed of the following main components:

[0431] 1. Data Acquisition Module

[0432] 2. Data Analysis Module

[0433] 3. Alternative Recipe Generation Module

[0434] 4. User Interface Module

[0435] Program processing

[0436] Data Acquisition Module

[0437] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[0438] Data Analysis Module

[0439] The data collected by the server is analyzed using natural language processing (NLP). Specifically, the following steps are taken:

[0440] The recipe information is divided, and each ingredient is tagged as a separate item.

[0441] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[0442] The analysis results extract detailed information such as ingredient types, nutritional value, and allergen information. This makes it easier to generate alternative recipes in the next step.

[0443] Alternative recipe generation module

[0444] The server uses an AI model (e.g., a machine learning model) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination in the dish.

[0445] For example, if a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest a dairy-free alternative (for example, soy cream) and generate an optimal recipe using it.

[0446] User Interface Module

[0447] Users enter specific requirements (e.g., allergy information, requests for specific ingredients) via a chatbot. This input data is then sent to the server via the device.

[0448] The server searches the database based on the received requirements and filters the recipes accordingly. For example, in response to a request from a user with a dairy allergy, it searches for and displays recipes that do not use dairy products.

[0449] If a recipe is not found, the server uses an alternative recipe generation module to construct a new recipe and presents the optimized recipe to the user using a text generation module that explains it in natural language.

[0450] For example, if a user requests "I have an egg allergy, but I want pancakes without eggs," the device sends this request to the server, which then searches for and generates a suitable recipe. The generated recipe is then displayed to the user in a detailed explanation format.

[0451] This system allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge. The system aims to ensure a stable food supply and can meet the diverse needs of users.

[0452] The following describes the processing flow.

[0453] Step 1:

[0454] The server collects recipe information from recipe websites and ingredient databases on the internet. Specifically, it uses scraping tools to obtain recipe titles, ingredients, cooking instructions, and nutritional information, and stores them in a database.

[0455] Step 2:

[0456] The server analyzes the collected recipe information. Natural language processing (NLP) is used to split and tag the ingredient list and cooking instructions for each recipe. For example, the ingredient "milk" is classified as "dairy products".

[0457] Step 3:

[0458] The server references a nutrition database and calculates nutritional information such as calories, protein, fat, and carbohydrates for each ingredient. Based on this information, it calculates the total nutritional value of each recipe.

[0459] Step 4:

[0460] The server uses an AI model to generate substitutes for each ingredient. For example, it creates a specific list of alternatives, such as suggesting soy milk instead of cow's milk.

[0461] Step 5:

[0462] The server simulates new recipe combinations using the generated substitutes. The simulation considers factors such as the balance of flavors, nutritional value, and allergen elimination. For example, it evaluates variations that use cashew cream instead of regular cream.

[0463] Step 6:

[0464] The user uses the chatbot function to enter specific requirements. For example, they might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[0465] Step 7:

[0466] The device analyzes the user's requirements and extracts specific conditions (e.g., "dairy allergy," "cream," "pasta"). The extracted results are then sent to the server.

[0467] Step 8:

[0468] The server filters the database based on the user's requirements and searches for relevant recipes. For example, it might search for pasta recipes that use cream without dairy products.

[0469] Step 9:

[0470] If a matching recipe is not found, the server will use an alternative recipe generation module to create a new alternative recipe. For example, it might generate a pasta recipe where cream is replaced with soy cream.

[0471] Step 10:

[0472] The server uses a text generation module to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might display, "This recipe uses soy cream instead of regular cream."

[0473] Step 11:

[0474] The device receives the best alternative recipe from the server and presents it to the user. The user can then review the presented recipe and learn about the specific cooking steps and ingredient list.

[0475] (Example 1)

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

[0477] Conventional food recipe systems have struggled to easily generate and optimize alternative recipes to meet specific user requirements. Furthermore, manual recipe collection and analysis are time-consuming, preventing users from quickly obtaining their desired alternative recipes. Additionally, recipe generation that considers the nutritional and allergen information of individual ingredients is insufficient.

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

[0479] In this invention, the server includes means for collecting recipe information from multiple websites that provide recipe information via a communication network; means for analyzing the collected recipe information using natural language processing technology and tagging each ingredient as an independent item; means for referring to a nutrition database and calculating nutritional information for each ingredient; means for generating substitutes for each ingredient using a machine learning model; means for simulating new recipes using the generated substitutes; and means for receiving specific requirements via a user terminal and presenting filtered and optimized recipes. This makes it possible to provide alternative recipes that quickly and appropriately respond to the user's specific requirements.

[0480] A "communication network" is a collection of technical means and protocols used to exchange data, and refers to wide-area communication systems, including the Internet.

[0481] "Recipe information" refers to data containing detailed information about how to prepare a dish, including a specific list of ingredients, cooking steps, and nutritional information.

[0482] A "website" refers to a collection of online pages that provide information accessible via the internet.

[0483] "Natural language processing technology" refers to the technology that enables computers to understand, analyze, generate, and respond to human language, including tasks such as text segmentation, tagging, and semantic understanding.

[0484] "Tagging" is the process of classifying data into specific categories or attributes and adding annotations or labels to make it identifiable.

[0485] A "nutrition database" is a database that collects information on the nutritional components of food, including data on nutrients such as energy, vitamins, and minerals for each food item.

[0486] A "machine learning model" is a type of artificial intelligence that learns patterns based on data and performs tasks such as prediction, classification, and generation.

[0487] A "substitute" is an ingredient used in place of the original ingredient, and is selected to have similar nutritional value and taste characteristics.

[0488] A "simulation" is a trial or test conducted under a virtual environment or conditions, a process of observing the results by imitating a real-world situation.

[0489] A "user terminal" refers to a device that a user directly operates, and includes personal computers, smartphones, tablets, and other similar devices.

[0490] "Requirements" refer to requests or preferences submitted by users based on specific conditions or desires, and include specific needs such as allergy information or the use of certain ingredients.

[0491] "Filtering" refers to the process of selecting data based on specific criteria and extracting relevant information.

[0492] "Optimization" refers to adjusting a system or process to achieve the best results under specific goals and constraints.

[0493] This invention is a system for users to quickly and effectively generate and provide alternative recipes based on specific requirements. This system mainly consists of a server, user terminals, and a database connected via a communication network.

[0494] System Configuration

[0495] The server is connected to the internet and is responsible for collecting recipe information from multiple recipe websites. Specifically, it uses the Python requests library to access specified websites and uses BeautifulSoup to scrape the necessary information (ingredients list, cooking instructions, nutritional information) from the web pages. The collected data is stored in JSON format or in a relational database such as MySQL or PostgreSQL.

[0496] Specific example: The server regularly collects ingredient lists, cooking instructions, and nutritional information from AllRecipes and Cookpad, and stores them in a database, ensuring that the latest recipe information is always updated.

[0497] Furthermore, the server also plays a role in analyzing the collected recipe information using natural language processing (NLP) techniques. Specifically, it uses Python NLP libraries (such as NLTK and SpaCy) to analyze the recipe text and tag each ingredient as a separate item. It also refers to nutrition databases (e.g., the USDA Food Database) to calculate the nutritional information for each ingredient.

[0498] Specific example: If a recipe includes "tomatoes, onions, and garlic," tags such as "vegetable" and "spice" will be assigned to each ingredient, and nutritional information will be calculated.

[0499] In the next stage, the server uses a machine learning model (e.g., Scikit-learn's RandomForestClassifier) ​​to generate substitutes for each ingredient from the collected data. In this process, ingredients with similar nutritional value and flavor characteristics are suggested. New recipes using the generated substitutes are then simulated by the AI ​​model. The simulation results are optimized, taking into account factors such as the balance of flavors, nutritional value, and allergen elimination.

[0500] Specific example: If a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest soy milk cream as an alternative and provide an optimal recipe using it.

[0501] Through the user's terminal, the user enters specific requirements (for example, allergy information or a desire to use specific ingredients) into the chatbot. The terminal sends these requirements to the server, which searches the database based on the received requirements. If a suitable recipe is not found, the server uses an alternative recipe generation module to construct a new recipe and provides the user with recipe information optimized for them.

[0502] Specific example: If a user requests "I have an egg allergy, but I want pancakes without eggs," that requirement is sent from the device to the server. The server searches for and generates a suitable recipe and presents it to the user.

[0503] Example of a prompt

[0504] Data collection prompt: "Collect recipe information, including ingredient lists, cooking instructions, and nutritional information, from recipe websites on the internet and save it in JSON format."

[0505] Data analysis prompt: "Analyze the collected recipe data, tag each ingredient, calculate nutritional information, and save it in JSON format."

[0506] Prompt for generating alternative recipes: "Use an AI model to generate dairy-free pasta recipes for users with dairy allergies."

[0507] User interface prompt: "Based on the user's requirements (e.g., egg allergy), please provide and display the appropriate alternative recipe in a detailed format."

[0508] Through the above means, it becomes possible to provide a system that allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge.

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

[0510] Step 1: Data Collection

[0511] The server connects to the internet and accesses multiple recipe websites. This connection uses the Python requests library to send HTTP requests. The server retrieves HTML documents from each website. Specifically, it accesses web pages using the requests.get(URL) method and retrieves the HTML data received as a response.

[0512] Input: URLs of multiple specified recipe websites.

[0513] Output: HTML document corresponding to each URL.

[0514] Step 2: Web scraping

[0515] The server uses BeautifulSoup to parse and extract HTML documents. Specifically, it uses `soup = BeautifulSoup(html, 'html.parser')` to extract the ingredient list, cooking instructions, and nutritional information for each recipe.

[0516] Input: The HTML document obtained in Step 1.

[0517] Output: Data including recipe ingredient list, cooking instructions, and nutritional information.

[0518] Step 3: Save Data

[0519] The server saves the extracted recipe data in JSON format or a relational database. For example, it connects to a MySQL database and executes an SQL query like INSERT INTO recipes (title, ingredients, instructions, nutrition) VALUES (...).

[0520] Input: Recipe data extracted in Step 2.

[0521] Output: Recipe information stored in a JSON file or database.

[0522] Step 4: Natural Language Processing (NLP)

[0523] The server analyzes the collected and stored recipe data using a Python NLP library (e.g., NLTK or SpaCy). Specifically, it splits the recipe text and tags each ingredient as an independent item. The library is loaded like this: nlp = spacy.load('en_core_web_sm') and the analysis is performed with doc = nlp(recipe_text).

[0524] Input: Recipe text retrieved from the database.

[0525] Output: Data for each tagged material.

[0526] Step 5: Calculate nutritional information

[0527] The server references a nutrition database (e.g., the USDA Food Database) and calculates the nutritional information for each tagged ingredient. Specifically, it calculates the energy, vitamins, minerals, etc. values ​​for each ingredient and sets it up as follows: `nutrition_info = calculate_nutrition(ingredient)`.

[0528] Input: Material data tagged in Step 4.

[0529] Output: Recipe data with added nutritional information.

[0530] Step 6: Generating a substitute for the material

[0531] The server uses a machine learning model (for example, Scikit-learn's RandomForestClassifier) ​​to generate substitutes for each ingredient. For example, it might substitute "dairy products" with "soy cream." Substitutes are suggested using a method like model.predict(alternative_ingredient).

[0532] Input: Recipe data with nutritional information added in Step 5.

[0533] Output: List of materials for which alternatives have been suggested.

[0534] Step 7: Simulation of alternative recipes

[0535] The server simulates a new recipe using the generated substitute ingredients. The simulation uses an AI model that considers factors such as flavor balance, nutritional value, and allergen elimination. The simulation is executed using a command like `simulate_recipe(new_ingredients)`.

[0536] Input: The list of alternatives suggested in Step 6.

[0537] Output: A simulated new recipe.

[0538] Step 8: Enter user requirements

[0539] The user enters specific requirements into the chatbot via their device. For example, they might type, "I have an egg allergy, so I'd like egg-free pancakes."

[0540] Input: User requirements (e.g., allergy information).

[0541] Output: Requirements data from the terminal to the server.

[0542] Step 9: Submitting Requirements

[0543] The terminal sends user requirements to the server. The requirements data is delivered to the server via network communication.

[0544] Input: User requirements entered in Step 8.

[0545] Output: Requirements data sent to the server.

[0546] Step 10: Search and display recipes

[0547] The server searches the database for a recipe that matches the user's requirements. If no suitable recipe is found, it uses an alternative recipe generation module to create a new recipe. It then generates optimized recipe information.

[0548] Input: Requirements data sent to the server.

[0549] Output: A recipe that meets the user requirements, or an alternative recipe that has been generated.

[0550] Step 11: Providing information to users

[0551] The terminal displays recipe information received from the server to the user. A GUI (Graphical User Interface) is used for this purpose.

[0552] Input: Recipe information sent from the server.

[0553] Output: Recipe information displayed on the terminal.

[0554] (Application Example 1)

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

[0556] Modern food delivery services struggle to accommodate the diverse needs of users, particularly allergies and dietary preferences. Users have difficulty finding ingredients and recipes that suit their health and tastes, and as a result, obtaining suitable alternative recipes requires considerable time and effort. Furthermore, there are limited means of quickly ordering meals based on these alternative recipes. Thus, current food delivery systems face the challenge of not being able to fully meet the specific needs of users.

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

[0558] In this invention, the server includes means for collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes, means for receiving specific requirements from the user and presenting filtered and optimized recipes, means for collecting and storing the user's allergy information and food preferences, and means for enabling the ordering of dishes based on the alternative recipes based on the collected user information. As a result, the user can not only quickly obtain alternative recipes that suit their preferences and health condition, but also immediately order dishes through a food delivery service based on the generated alternative recipes.

[0559] A "food ingredient recipe database" is a collection of data containing multiple recipes stored on the internet or in dedicated databases.

[0560] "Recipe information" refers to detailed information about each recipe, such as the ingredient list, cooking instructions, and nutritional information.

[0561] A "substitute" refers to an alternative ingredient used to replace an ingredient in the original recipe, based on the specific requirements of a particular user.

[0562] "Simulation" is the process of experimenting with new recipes using the generated substitutes.

[0563] "Specific requirements" refer to individual conditions such as allergy information, food preferences, and nutritional requirements that users possess.

[0564] "Filtering" is the process of selecting recipe information or alternative recipes that meet specific requirements.

[0565] "Optimization" is the process of adjustment and improvement to extract and propose the recipe that best suits specific requirements.

[0566] A "user" refers to an individual or group that uses the system to obtain alternative recipes and then orders dishes based on those recipes.

[0567] "Allergy information" refers to information about foods that a user may be allergic to.

[0568] "Food preferences" refers to information about a user's preferences regarding food ingredients they particularly want to use or avoid.

[0569] An "order" is the act of a user requesting the purchase and delivery of a dish generated based on an alternative recipe.

[0570] A "server" refers to a computer system that collects, analyzes, optimizes, and provides recipe information.

[0571] The program for the system that realizes this invention is described in detail below.

[0572] System configuration and operation

[0573] This system primarily consists of three components: a server, a terminal, and a user. The server plays the main role of collecting and analyzing recipe information, generating alternative recipes, and providing information to users. The terminal is the interface where users input information and mediates communication with the server. The user is the entity that inputs specific conditions and selects and orders optimized alternative recipes.

[0574] 1. Server operation:

[0575] The server operates using the following procedure.

[0576] Recipe information is collected from a database of food ingredient recipes. The collected recipe information includes ingredient lists, cooking instructions, and nutritional information.

[0577] The collected recipe information is segmented and tagged using natural language processing (NLP), and the nutritional information for each ingredient is calculated by referring to a nutrition database.

[0578] Using an AI model, we generate alternative ingredients based on specific conditions and simulate new recipe combinations.

[0579] The system receives specific requirements from users (e.g., allergy information, food preferences) and presents filtered and optimized recipes.

[0580] Based on the collected user information, it will be possible to order dishes based on alternative recipes.

[0581] 2. Device operation:

[0582] Users input allergy information and food preferences via their devices. This information is sent to the server in JSON format.

[0583] 3. User Interface:

[0584] Users can receive alternative recipe suggestions by entering specific requirements using a terminal. For example, they might enter a specific requirement such as, "I have a dairy allergy, so I would like pasta without cream." The server then suggests alternative ingredients and presents an optimized recipe. Users can review the suggested recipe and order a meal based on it.

[0585] Hardware and software to be used

[0586] Server: Collects and analyzes recipe information, generates alternative recipes, and provides information. The server runs natural language processing models, a nutrition database, and AI models.

[0587] Device: A smartphone or tablet device used by the user, providing the user interface. The food delivery application is installed on it.

[0588] Examples of specific cases and prompt statements

[0589] For example, if a user has a dairy allergy and wants a vegan diet, they would enter the following through their device:

[0590] "I have a dairy allergy and would like a vegan diet. Please suggest pasta recipes that do not use cream."

[0591] This prompt is used by the server to generate alternative recipes in response to the user's request and suggest a specific recipe that is suitable for the user.

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

[0593] Step 1:

[0594] The user uses a terminal to input allergy information and food preferences. This information is sent to the server in JSON format. The input data includes specific allergy information (e.g., dairy allergy) and preferences (e.g., vegan). The server receives this data and stores it in its internal database.

[0595] Step 2:

[0596] The server collects recipe information from a database of food ingredient recipes. Specifically, it uses recipe websites on the internet and food ingredient database APIs to obtain recipe data including ingredient lists, cooking instructions, and nutritional information. This data is stored in JSON format or a relational database (e.g., MySQL).

[0597] Step 3:

[0598] The server collects recipe information and uses natural language processing (NLP) to segment and tag it. Each recipe's ingredients are classified as a separate item and tagged accordingly. The input data is the recipe information, and the output data is a list of tagged ingredients. During this process, NLP libraries (e.g., NLTK, spaCy) are used to analyze the data.

[0599] Step 4:

[0600] The server references a nutrition database and calculates the nutritional information for each ingredient. Based on a tagged list of ingredients, it retrieves the corresponding nutritional information from the nutrition database (e.g., USDA nutrition database) and adds the calculation results. The input data is the ingredient list, and the output data is the ingredient list with the nutritional information added.

[0601] Step 5:

[0602] The server uses an AI model to generate substitutes for each ingredient. Based on the user's specific requirements (e.g., dairy allergy, vegan), the AI ​​model (e.g., machine learning model, transformer) suggests appropriate substitute ingredients. The input data is a list of ingredients with nutritional information, and the output data is a list of substitute ingredients.

[0603] Step 6:

[0604] The server simulates new recipe combinations using substitute ingredients. Based on an AI model, it generates new recipes considering the balance of flavors and nutritional value of the dishes. The input data is a list of substitute ingredients, and the output data is the new recipe.

[0605] Step 7:

[0606] The system filters specific requirements entered by the user via their device and presents optimized recipes. The server searches for recipes that match the user's requirements and extracts the relevant recipes. The input data is the user's requirements, and the output data is the optimized recipe.

[0607] Step 8:

[0608] Based on user information collected by the server, it enables ordering of dishes based on alternative recipes. Users can view alternative recipes on their terminals and, if they like them, proceed directly to the order screen. Input data is the user's order request, and output data is order confirmation information.

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

[0610] This invention proposes a system for collecting, analyzing, and optimizing food recipe information, and providing alternative recipes tailored to the user's requirements and preferences. Specific embodiments thereof are described below.

[0611] System Configuration

[0612] This system is broadly composed of the following main components:

[0613] 1. Data Acquisition Module

[0614] 2. Data Analysis Module

[0615] 3. Alternative Recipe Generation Module

[0616] 4. Emotional Engine

[0617] 5. User Interface Module

[0618] Program processing

[0619] Data Acquisition Module

[0620] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[0621] Data Analysis Module

[0622] The data collected by the server is analyzed using natural language processing (NLP). Specifically, the following steps are taken:

[0623] The recipe information is divided, and each ingredient is tagged as a separate item.

[0624] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[0625] The analysis results extract detailed information such as ingredient types, nutritional value, and allergen information. This makes it easier to generate alternative recipes in the next step.

[0626] Alternative recipe generation module

[0627] The server uses an AI model (e.g., a machine learning model) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination in the dish.

[0628] For example, if a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest a dairy-free alternative (for example, soy cream) and generate an optimal recipe using it.

[0629] Emotional Engine

[0630] The emotion engine recognizes the user's emotions. This emotion engine analyzes the user's emotional state (e.g., joy, sadness, stress) using text input, voice, and facial recognition technology.

[0631] The recognized emotional information is reflected in the recipe suggestions. For example, if the user is feeling stressed, the system will suggest recipes using ingredients that have a relaxing effect.

[0632] User Interface Module

[0633] Users enter specific requirements (e.g., allergy information, requests for specific ingredients) via a chatbot. This input data is sent to the server through the device. For example, a user might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[0634] The emotion engine analyzes the user's input, facial expressions, and tone of voice to recognize the user's current emotional state. This emotional information is sent to the server and incorporated into the recipe recommendation process.

[0635] The server searches the database and filters the recipes based on the received requirements and emotional information. For example, when searching for pasta recipes using cream without dairy products, if the user is feeling down, it prioritizes displaying recipes that include ingredients that can lift their mood.

[0636] For example, if a user requests egg-free pancakes despite having an egg allergy, and the emotion engine simultaneously detects stress, the device sends this requirement and emotional information to the server. The server searches for and generates a suitable recipe, suggesting an optimized recipe that includes ingredients with relaxing effects (e.g., vanilla extract).

[0637] A text generation module is used to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might say, "This recipe uses banana puree instead of eggs and also includes vanilla extract for a relaxing effect."

[0638] This system allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge. Furthermore, it enables recipe suggestions tailored to the user's emotional state, providing more personalized support.

[0639] The following describes the processing flow.

[0640] Step 1:

[0641] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe, and this data is stored in the database.

[0642] Step 2:

[0643] The server analyzes the collected recipe information using natural language processing (NLP). Specifically, the recipe information is divided, and each ingredient is tagged as an independent item. For example, the ingredient "milk" is classified as "dairy products."

[0644] Step 3:

[0645] The server references a nutrition database and calculates the nutritional information for each ingredient. Specifically, it retrieves information such as calories, protein, fat, and carbohydrates for each ingredient and calculates the total nutritional value for each recipe.

[0646] Step 4:

[0647] The server uses an AI model to generate substitutes for each ingredient. For example, it suggests "soy milk" for "milk." It also lists alternative candidates for other ingredients and provides substitutes that meet the user's needs.

[0648] Step 5:

[0649] The server simulates new recipe combinations using the generated substitutes. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination. For example, it evaluates variations that use cashew cream instead of regular cream.

[0650] Step 6:

[0651] The user uses the chatbot function to enter specific requirements. For example, they might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[0652] Step 7:

[0653] The terminal analyzes the user's requirements and extracts specific conditions. The extracted conditions (e.g., "dairy allergy," "cream," "pasta") are then sent to the server.

[0654] Step 8:

[0655] The emotion engine recognizes the user's emotions. This involves a process of analyzing the user's emotional state (e.g., joy, sadness, stress) using text input, voice, and facial recognition technology.

[0656] Step 9:

[0657] The server filters the database based on user requirements and emotional information to find relevant recipes. For example, if searching for pasta recipes using cream without dairy products, and the user is feeling stressed, the server will prioritize displaying recipes that use ingredients with relaxing properties.

[0658] Step 10:

[0659] If a matching recipe is not found, the server uses an alternative recipe generation module to create a new alternative recipe. For example, it might generate a pasta recipe where cream is replaced with soy cream.

[0660] Step 11:

[0661] The server uses a text generation module to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might display: "This recipe uses soy cream instead of regular cream."

[0662] Step 12:

[0663] The device receives the best alternative recipe from the server and presents it to the user. The user can then review the presented recipe and learn about the specific cooking steps and ingredient list.

[0664] Step 13:

[0665] Once a user selects a suggested recipe, there are steps that provide additional cooking advice and customization options. In this way, users can easily find and execute the best alternative recipe.

[0666] (Example 2)

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

[0668] Conventional food recipe provision systems struggle to suggest recipes that take into account the user's specific requirements and emotional state. As a result, users may be offered recipes that do not match their preferences or feelings, leading to decreased satisfaction. Furthermore, the lack of detailed data analysis regarding nutritional information and ingredient substitutes makes it difficult to suggest alternative recipes that take health and allergies into consideration.

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

[0670] In this invention, the server includes means for collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information using natural language processing and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes with a machine learning model, and means for receiving specific requirements and emotional states from the user, analyzing the emotional information using an emotion analysis engine, and presenting filtered and optimized recipes. This makes it possible to optimize recipes according to the user's specific requirements and emotional states, and to suggest alternative recipes that take health and allergies into consideration.

[0671] A "food ingredient recipe" is a description of information about food ingredients and how to prepare them.

[0672] A "database" is a system for systematically managing and retrieving large amounts of data.

[0673] "Recipe information" includes instructions on cooking, ingredients to be used, cooking procedures, and nutritional information.

[0674] "Natural language processing" is a technology that enables computers to understand, analyze, and generate human language.

[0675] "Analysis" is the process of examining collected data in detail and understanding its meaning and patterns.

[0676] A "substitute" is another material used to replace a particular material.

[0677] A "machine learning model" is an algorithm that learns patterns from a series of data and uses them to make predictions and classifications on new data.

[0678] "Simulation" is the process of imitating actual behavior by virtually reproducing processes and systems in the real world.

[0679] The "specific requirements" of a "user" refer to the specific requests or conditions that a user has regarding a recipe.

[0680] An "emotion analysis engine" is a technology that analyzes user input data (text, voice, images) to recognize their emotional state.

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

[0682] "Optimization" is the process of making adjustments to obtain the best possible results under specific conditions and constraints.

[0683] This invention is a system that collects, analyzes, and optimizes food recipe information, and provides alternative recipes tailored to the user's requirements and preferences. This system is broadly composed of the following main components:

[0684] 1. Data Acquisition Module

[0685] 2. Data Analysis Module

[0686] 3. Alternative Recipe Generation Module

[0687] 4. Emotional Engine

[0688] 5. User Interface Module

[0689] System Configuration

[0690] Data Acquisition Module

[0691] The server collects recipe information from recipe websites and ingredient databases on the internet. Specifically, it uses web scraping with libraries such as Python's BeautifulSoup and Scrapy to collect ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases (e.g., MySQL or PostgreSQL).

[0692] Data Analysis Module

[0693] The server analyzes the collected data using natural language processing (NLP). At this stage, NLP libraries (e.g., spaCy or NLTK) are used to tokenize recipe information and extract important keywords and ingredients. Nutritional information for each ingredient is also calculated by referencing a nutrition database (e.g., the USDA Nutrient Database).

[0694] Alternative recipe generation module

[0695] The server uses machine learning models (e.g., models built using TensorFlow or PyTorch) to generate alternative recipes based on user requirements and sentiment information. This includes the ability to suggest and simulate alternative ingredients. For example, if a user with a dairy allergy wants to make a pasta dish that uses cream, the server will suggest a dairy-free alternative (e.g., soy cream) and generate an optimal recipe using it.

[0696] Emotional Engine

[0697] An emotion engine recognizes the user's emotions. This is a technology that analyzes the user's text input, voice, and image data to recognize their emotional state (e.g., joy, sadness, stress). Examples include using the Google Cloud Vision API or IBM Watson Tone Analyzer.

[0698] User Interface Module

[0699] Users input specific requirements (e.g., allergy information, desired ingredients) via a chatbot. This input data is sent to the server through the device. Based on the received requirements and sentiment information, the server searches its database and filters for suitable recipes. The generated recipes are explained in natural language and presented to the user in an easy-to-understand format.

[0700] Examples of prompt statements

[0701] "I have a dairy allergy, but I'd like a pasta recipe that uses cream. I'm feeling a bit down today, so please let me know if you have any recipes that will cheer me up."

[0702] Examples

[0703] When a user enters a prompt into the chatbot, the device sends that input data to the server. The server first analyzes the recipe information collected by the data collection module using the data analysis module, and then recognizes the sentiment information using the sentiment engine. Subsequently, the alternative recipe generation module generates the optimal alternative recipe based on the user's requirements and sentiment. The generated recipe is then provided to the user via the user interface module. Through this series of processes, the user can efficiently obtain the optimal recipe that suits their requirements and sentiment.

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

[0705] Step 1: Data Collection

[0706] The server collects recipe information from multiple recipe websites and ingredient databases on the internet. This is done using web scraping libraries such as Python's BeautifulSoup and Scrapy.

[0707] Input: URL of the recipe website or API endpoint.

[0708] Data processing: The server retrieves HTML data from the web page and extracts the necessary information (e.g., ingredient list, cooking instructions, nutritional information, etc.).

[0709] Output: Recipe information stored in JSON format or a relational database.

[0710] Step 2: Data Analysis

[0711] The server analyzes the collected data using natural language processing (NLP). Specifically, recipe information is tokenized using an NLP library (e.g., spaCy, NLTK), and important keywords and tags are extracted.

[0712] Input: Recipe information saved in JSON format.

[0713] Data processing: The server tokenizes the ingredient list and tags each ingredient as an independent item. It also references a nutrition database (e.g., USDA Nutrient Database) to calculate the nutritional information for each ingredient.

[0714] Output: Data including analyzed recipe information, nutritional value, allergen information, etc.

[0715] Step 3: Emotion Analysis

[0716] The device acquires user input (text, voice, images) into the chatbot and sends it to the emotion engine. The emotion engine analyzes this data to recognize the user's emotional state.

[0717] Input: Text, audio, and image data from the user.

[0718] Data Processing: The emotion engine performs emotion analysis using NLP, facial recognition, and speech analysis technologies (e.g., Google Cloud Vision API and IBM Watson Tone Analyzer).

[0719] Output: User's emotional state (e.g., joy, sadness, stress).

[0720] Step 4: Generate alternative recipes

[0721] The server uses machine learning models (e.g., TensorFlow or PyTorch) to generate alternative recipes based on user requirements and sentiment information.

[0722] Input: Analyzed recipe information, nutritional data, user requirements, and emotional state.

[0723] Data Processing: The server considers user requirements and emotional information, suggesting alternative ingredients that are similar in nutritional value, allergen elimination, and taste characteristics. Machine learning models are used in this process to select the optimal ingredients.

[0724] Output: Optimized recipe using substitutes.

[0725] Step 5: Recipe suggestion

[0726] The server provides the generated alternative recipe to the user in an understandable format using a text generation module (e.g., natural language generation technology).

[0727] Input: Information on alternative recipes.

[0728] Data processing: The server generates recipe descriptions using natural language generation technology.

[0729] Output: The recipe description presented to the user.

[0730] Step 6: Presentation to the user

[0731] The device presents the generated recipe to the user.

[0732] Input: Recipe description sent from the server.

[0733] Data processing: The process by which the terminal formats recipe information and displays it in the user interface.

[0734] Output: The specific alternative recipe displayed on the user's screen.

[0735] Through these processing steps, users can efficiently obtain the optimal alternative recipe tailored to their requirements and emotional state.

[0736] (Application Example 2)

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

[0738] While modern food recipe systems can accommodate specific user requirements such as allergies and dietary restrictions, systems that offer personalized recipe suggestions based on a user's emotional state still do not exist. In particular, meal suggestions that take into account emotions such as stress and joy are lacking, making it difficult to enhance users' psychological and emotional satisfaction. Furthermore, there are limitations to generating optimized alternative recipes, posing a challenge in quickly responding to diverse user needs.

[0739] The specific processing performed by the specific 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 collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes, means for recognizing the user's emotions and making recipe suggestions based on them, and means for inputting emotions and requirements through a user interface and providing optimized recipes. This makes it possible to provide optimized alternative recipes that correspond to the user's specific requirements and emotional state.

[0740] A "food recipe database" is a digital structure for systematically storing and managing food recipe information.

[0741] "Recipe information" refers to a dataset containing detailed information such as ingredient lists, cooking instructions, and nutritional information.

[0742] A "food substitute" is an ingredient that can be used in place of a specific ingredient and has similar nutritional value or taste characteristics.

[0743] A "simulation" is the process of using data and algorithms to mimic real-world situations and predict outcomes under hypothetical conditions.

[0744] "Specific user requirements" refer to detailed conditions desired by individual users, such as allergy information, food preferences, and nutritional needs.

[0745] "Filtering" is the process of selecting data that meets specific criteria from a large amount of data.

[0746] An "optimized recipe" is a recipe that has been tailored to the user's specific requirements and emotional state to be the most suitable for them.

[0747] "Means of recognizing emotions" refers to technologies and software used to analyze and identify a user's emotional state.

[0748] A "user interface" is an interactive environment for input and output that allows a user to interact with a system.

[0749] "Means of collection" refers to the functions and methods for obtaining recipe information from databases or the internet.

[0750] "Means of analysis" refers to the process of analyzing collected data and extracting meaningful information.

[0751] "Means of generating substitutes" refer to methods or algorithms for suggesting ingredients that can be used as substitutes for specific ingredients.

[0752] "Means of presentation" refers to methods and technologies for displaying user-optimized recipe information in an easy-to-understand format.

[0753] This invention is implemented as a system that provides food delivery services that respond to the specific requirements and emotional states of users. Specific embodiments of this system are described below.

[0754] System Configuration

[0755] This system includes the following main components.

[0756] 1. Data Acquisition Module

[0757] 2. Data Analysis Module

[0758] 3. Alternative Recipe Generation Module

[0759] 4. Emotion Recognition Engine

[0760] 5. User Interface Module

[0761] Data Acquisition Module

[0762] The server collects recipe information from online recipe and ingredient databases. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[0763] Data Analysis Module

[0764] The server analyzes the collected data using natural language processing (NLP). Specifically, it follows these steps:

[0765] The recipe information is divided, and each ingredient is tagged as a separate item.

[0766] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[0767] The analysis results extract detailed information such as the type of material, nutritional value, and allergen information.

[0768] Alternative recipe generation module

[0769] The server uses AI models (e.g., machine learning models) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This generates alternative recipes that are best suited to the user's specific requirements.

[0770] Emotion recognition engine

[0771] The emotion recognition engine recognizes the user's emotions using text input, voice, and facial recognition technology. The analyzed emotion information is then reflected in recipe suggestions. For example, if the user is feeling stressed, the engine will suggest recipes using ingredients that have a relaxing effect.

[0772] User Interface Module

[0773] The user enters specific requirements (e.g., allergy information, preference for certain ingredients) through the user interface. This input data is then sent to the server via the terminal.

[0774] For example, if a user enters "I have an egg allergy, but I want pancakes that don't use eggs," and the emotion recognition engine detects stress, the following prompt message will be generated.

[0775] Generate a recipe that meets the following requirements: Without eggs suitable for someone feeling stressed.

[0776] Sending this prompt to the server's AI model generates an optimized pancake recipe that includes vanilla extract, which has stress-reducing effects.

[0777] Examples

[0778] For example, if a user enters a request stating, "I have a dairy allergy, but I want to eat pasta with cream," the emotion recognition engine will recognize the user's emotional state and suggest a dairy-free alternative (e.g., soy cream). Furthermore, a recipe including ingredients that can improve the user's mood will be generated, tailored to their emotional state.

[0779] This allows users to quickly find the perfect meal tailored to their emotional state and specific requirements. The system can improve user satisfaction and provide a personalized food delivery service.

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

[0781] Step 1:

[0782] The server collects recipe information from recipe and ingredient databases on the internet. It uses HTTP requests to retrieve data from APIs and saves the retrieved data in JSON format. The input is the API URL, and the output is recipe data in JSON format.

[0783] Step 2:

[0784] The server analyzes the collected recipe data using a natural language processing (NLP) library. This process divides the recipe information and tags each ingredient as an independent item. It also refers to a nutrition database and calculates the nutritional information for each ingredient. The input is recipe data in JSON format, and the output is the analyzed recipe data and nutritional information.

[0785] Step 3:

[0786] The server receives specific requirements and sentiment information entered by the user. It collects requirements entered by the user through the user interface and sentiment information recognized by the sentiment recognition engine. The input consists of the user's requirements and sentiment information, while the output consists of the received requirements and sentiment information.

[0787] Step 4:

[0788] The emotion recognition engine analyzes user input text and voice to recognize the user's emotional state. Specifically, it uses speech recognition software and facial recognition technology to evaluate the user's emotions. The input is the user's text and voice data, and the output is the recognized emotion information.

[0789] Step 5:

[0790] The server uses an AI model to generate alternative recipes based on analyzed recipe data, user requirements, and sentiment information. This process generates the optimal recipe by combining alternative ingredients that meet the user's requirements (e.g., allergy information). The input is the analyzed recipe data, user requirements, and sentiment information, and the output is the generated alternative recipe.

[0791] Step 6:

[0792] The server filters and optimizes the generated alternative recipes. During this process, it selects the optimal recipe, taking into account factors such as the nutritional value of the ingredients used and the user's emotional state. The input is the generated alternative recipe, and the output is the optimized, best-in-class recipe.

[0793] Step 7:

[0794] The user interface presents optimized recipe information to the user. A text generation module is used to generate detailed recipe descriptions for easy viewing. The input is optimized recipe information, and the output is a text-based recipe description for display to the user.

[0795] As a concrete example of its operation, if a user enters a request such as "I have an egg allergy, but I would like pancakes that do not contain eggs," and the emotion recognition engine detects stress, the following prompt message will be generated.

[0796] Generate a recipe that meets the following requirements: Without eggs suitable for someone feeling stressed.

[0797] By sending this prompt to the AI ​​model, an optimized pancake recipe containing vanilla extract, known for its stress-reducing effects, is generated. Finally, the user is shown through the user interface the message, "This recipe uses banana puree instead of eggs and also includes relaxing vanilla extract."

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

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

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

[0801] [Third Embodiment]

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

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

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

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

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

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

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

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

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

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

[0812] In the headset terminal 314, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

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

[0814] The system of the present invention collects, analyzes, and optimizes food recipe information, and provides alternative recipes tailored to the user's requirements. Specific embodiments are described below.

[0815] System Configuration

[0816] This system is broadly composed of the following main components:

[0817] 1. Data Acquisition Module

[0818] 2. Data Analysis Module

[0819] 3. Alternative Recipe Generation Module

[0820] 4. User Interface Module

[0821] Program processing

[0822] Data Acquisition Module

[0823] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[0824] Data Analysis Module

[0825] The data collected by the server is analyzed using natural language processing (NLP). Specifically, the following steps are taken:

[0826] The recipe information is divided, and each ingredient is tagged as a separate item.

[0827] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[0828] The analysis results extract detailed information such as ingredient types, nutritional value, and allergen information. This makes it easier to generate alternative recipes in the next step.

[0829] Alternative recipe generation module

[0830] The server uses an AI model (e.g., a machine learning model) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination in the dish.

[0831] For example, if a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest a dairy-free alternative (for example, soy cream) and generate an optimal recipe using it.

[0832] User Interface Module

[0833] Users enter specific requirements (e.g., allergy information, requests for specific ingredients) via a chatbot. This input data is then sent to the server via the device.

[0834] The server searches the database based on the received requirements and filters the recipes accordingly. For example, in response to a request from a user with a dairy allergy, it searches for and displays recipes that do not use dairy products.

[0835] If a recipe is not found, the server uses an alternative recipe generation module to construct a new recipe and presents the optimized recipe to the user using a text generation module that explains it in natural language.

[0836] For example, if a user requests "I have an egg allergy, but I want pancakes without eggs," the device sends this request to the server, which then searches for and generates a suitable recipe. The generated recipe is then displayed to the user in a detailed explanation format.

[0837] This system allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge. The system aims to ensure a stable food supply and can meet the diverse needs of users.

[0838] The following describes the processing flow.

[0839] Step 1:

[0840] The server collects recipe information from recipe websites and ingredient databases on the internet. Specifically, it uses scraping tools to obtain recipe titles, ingredients, cooking instructions, and nutritional information, and stores them in a database.

[0841] Step 2:

[0842] The server analyzes the collected recipe information. Natural language processing (NLP) is used to split and tag the ingredient list and cooking instructions for each recipe. For example, the ingredient "milk" is classified as "dairy products".

[0843] Step 3:

[0844] The server references a nutrition database and calculates nutritional information such as calories, protein, fat, and carbohydrates for each ingredient. Based on this information, it calculates the total nutritional value of each recipe.

[0845] Step 4:

[0846] The server uses an AI model to generate substitutes for each ingredient. For example, it creates a specific list of alternatives, such as suggesting soy milk instead of cow's milk.

[0847] Step 5:

[0848] The server simulates new recipe combinations using the generated substitutes. The simulation considers factors such as the balance of flavors, nutritional value, and allergen elimination. For example, it evaluates variations that use cashew cream instead of regular cream.

[0849] Step 6:

[0850] The user uses the chatbot function to enter specific requirements. For example, they might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[0851] Step 7:

[0852] The device analyzes the user's requirements and extracts specific conditions (e.g., "dairy allergy," "cream," "pasta"). The extracted results are then sent to the server.

[0853] Step 8:

[0854] The server filters the database based on the user's requirements and searches for relevant recipes. For example, it might search for pasta recipes that use cream without dairy products.

[0855] Step 9:

[0856] If a matching recipe is not found, the server will use an alternative recipe generation module to create a new alternative recipe. For example, it might generate a pasta recipe where cream is replaced with soy cream.

[0857] Step 10:

[0858] The server uses a text generation module to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might display, "This recipe uses soy cream instead of regular cream."

[0859] Step 11:

[0860] The device receives the best alternative recipe from the server and presents it to the user. The user can then review the presented recipe and learn about the specific cooking steps and ingredient list.

[0861] (Example 1)

[0862] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0863] Conventional food recipe systems have struggled to easily generate and optimize alternative recipes to meet specific user requirements. Furthermore, manual recipe collection and analysis are time-consuming, preventing users from quickly obtaining their desired alternative recipes. Additionally, recipe generation that considers the nutritional and allergen information of individual ingredients is insufficient.

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

[0865] In this invention, the server includes means for collecting recipe information from multiple websites that provide recipe information via a communication network; means for analyzing the collected recipe information using natural language processing technology and tagging each ingredient as an independent item; means for referring to a nutrition database and calculating nutritional information for each ingredient; means for generating substitutes for each ingredient using a machine learning model; means for simulating new recipes using the generated substitutes; and means for receiving specific requirements via a user terminal and presenting filtered and optimized recipes. This makes it possible to provide alternative recipes that quickly and appropriately respond to the user's specific requirements.

[0866] A "communication network" is a collection of technical means and protocols used to exchange data, and refers to wide-area communication systems, including the Internet.

[0867] "Recipe information" refers to data containing detailed information about how to prepare a dish, including a specific list of ingredients, cooking steps, and nutritional information.

[0868] A "website" refers to a collection of online pages that provide information accessible via the internet.

[0869] "Natural language processing technology" refers to the technology that enables computers to understand, analyze, generate, and respond to human language, including tasks such as text segmentation, tagging, and semantic understanding.

[0870] "Tagging" is the process of classifying data into specific categories or attributes and adding annotations or labels to make it identifiable.

[0871] A "nutrition database" is a database that collects information on the nutritional components of food, including data on nutrients such as energy, vitamins, and minerals for each food item.

[0872] A "machine learning model" is a type of artificial intelligence that learns patterns based on data and performs tasks such as prediction, classification, and generation.

[0873] A "substitute" is an ingredient used in place of the original ingredient, and is selected to have similar nutritional value and taste characteristics.

[0874] A "simulation" is a trial or test conducted under a virtual environment or conditions, a process of observing the results by imitating a real-world situation.

[0875] A "user terminal" refers to a device that a user directly operates, and includes personal computers, smartphones, tablets, and other similar devices.

[0876] "Requirements" refer to requests or preferences submitted by users based on specific conditions or desires, and include specific needs such as allergy information or the use of certain ingredients.

[0877] "Filtering" refers to the process of selecting data based on specific criteria and extracting relevant information.

[0878] "Optimization" refers to adjusting a system or process to achieve the best results under specific goals and constraints.

[0879] This invention is a system for users to quickly and effectively generate and provide alternative recipes based on specific requirements. This system mainly consists of a server, user terminals, and a database connected via a communication network.

[0880] System Configuration

[0881] The server is connected to the internet and is responsible for collecting recipe information from multiple recipe websites. Specifically, it uses the Python requests library to access specified websites and uses BeautifulSoup to scrape the necessary information (ingredients list, cooking instructions, nutritional information) from the web pages. The collected data is stored in JSON format or in a relational database such as MySQL or PostgreSQL.

[0882] Specific example: The server regularly collects ingredient lists, cooking instructions, and nutritional information from AllRecipes and Cookpad, and stores them in a database, ensuring that the latest recipe information is always updated.

[0883] Furthermore, the server also plays a role in analyzing the collected recipe information using natural language processing (NLP) techniques. Specifically, it uses Python NLP libraries (such as NLTK and SpaCy) to analyze the recipe text and tag each ingredient as a separate item. It also refers to nutrition databases (e.g., the USDA Food Database) to calculate the nutritional information for each ingredient.

[0884] Specific example: If a recipe includes "tomatoes, onions, and garlic," tags such as "vegetable" and "spice" will be assigned to each ingredient, and nutritional information will be calculated.

[0885] In the next stage, the server uses a machine learning model (e.g., Scikit-learn's RandomForestClassifier) ​​to generate substitutes for each ingredient from the collected data. In this process, ingredients with similar nutritional value and flavor characteristics are suggested. New recipes using the generated substitutes are then simulated by the AI ​​model. The simulation results are optimized, taking into account factors such as the balance of flavors, nutritional value, and allergen elimination.

[0886] Specific example: If a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest soy milk cream as an alternative and provide an optimal recipe using it.

[0887] Through the user's terminal, the user enters specific requirements (for example, allergy information or a desire to use specific ingredients) into the chatbot. The terminal sends these requirements to the server, which searches the database based on the received requirements. If a suitable recipe is not found, the server uses an alternative recipe generation module to construct a new recipe and provides the user with recipe information optimized for them.

[0888] Specific example: If a user requests "I have an egg allergy, but I want pancakes without eggs," that requirement is sent from the device to the server. The server searches for and generates a suitable recipe and presents it to the user.

[0889] Example of a prompt

[0890] Data collection prompt: "Collect recipe information, including ingredient lists, cooking instructions, and nutritional information, from recipe websites on the internet and save it in JSON format."

[0891] Data analysis prompt: "Analyze the collected recipe data, tag each ingredient, calculate nutritional information, and save it in JSON format."

[0892] Prompt for generating alternative recipes: "Use an AI model to generate dairy-free pasta recipes for users with dairy allergies."

[0893] User interface prompt: "Based on the user's requirements (e.g., egg allergy), please provide and display the appropriate alternative recipe in a detailed format."

[0894] Through the above means, it becomes possible to provide a system that allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge.

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

[0896] Step 1: Data Collection

[0897] The server connects to the internet and accesses multiple recipe websites. This connection uses the Python requests library to send HTTP requests. The server retrieves HTML documents from each website. Specifically, it accesses web pages using the requests.get(URL) method and retrieves the HTML data received as a response.

[0898] Input: URLs of multiple specified recipe websites.

[0899] Output: HTML document corresponding to each URL.

[0900] Step 2: Web scraping

[0901] The server uses BeautifulSoup to parse and extract HTML documents. Specifically, it uses `soup = BeautifulSoup(html, 'html.parser')` to extract the ingredient list, cooking instructions, and nutritional information for each recipe.

[0902] Input: The HTML document obtained in Step 1.

[0903] Output: Data including recipe ingredient list, cooking instructions, and nutritional information.

[0904] Step 3: Save Data

[0905] The server saves the extracted recipe data in JSON format or a relational database. For example, it connects to a MySQL database and executes an SQL query like INSERT INTO recipes (title, ingredients, instructions, nutrition) VALUES (...).

[0906] Input: Recipe data extracted in Step 2.

[0907] Output: Recipe information stored in a JSON file or database.

[0908] Step 4: Natural Language Processing (NLP)

[0909] The server analyzes the collected and stored recipe data using a Python NLP library (e.g., NLTK or SpaCy). Specifically, it splits the recipe text and tags each ingredient as an independent item. The library is loaded like this: nlp = spacy.load('en_core_web_sm') and the analysis is performed with doc = nlp(recipe_text).

[0910] Input: Recipe text retrieved from the database.

[0911] Output: Data for each tagged material.

[0912] Step 5: Calculate nutritional information

[0913] The server references a nutrition database (e.g., the USDA Food Database) and calculates the nutritional information for each tagged ingredient. Specifically, it calculates the energy, vitamins, minerals, etc. values ​​for each ingredient and sets it up as follows: `nutrition_info = calculate_nutrition(ingredient)`.

[0914] Input: Material data tagged in Step 4.

[0915] Output: Recipe data with added nutritional information.

[0916] Step 6: Generating a substitute for the material

[0917] The server uses a machine learning model (for example, Scikit-learn's RandomForestClassifier) ​​to generate substitutes for each ingredient. For example, it might substitute "dairy products" with "soy cream." Substitutes are suggested using a method like model.predict(alternative_ingredient).

[0918] Input: Recipe data with nutritional information added in Step 5.

[0919] Output: List of materials for which alternatives have been suggested.

[0920] Step 7: Simulation of alternative recipes

[0921] The server simulates a new recipe using the generated substitute ingredients. The simulation uses an AI model that considers factors such as flavor balance, nutritional value, and allergen elimination. The simulation is executed using a command like `simulate_recipe(new_ingredients)`.

[0922] Input: The list of alternatives suggested in Step 6.

[0923] Output: A simulated new recipe.

[0924] Step 8: Enter user requirements

[0925] The user enters specific requirements into the chatbot via their device. For example, they might type, "I have an egg allergy, so I'd like egg-free pancakes."

[0926] Input: User requirements (e.g., allergy information).

[0927] Output: Requirements data from the terminal to the server.

[0928] Step 9: Submitting Requirements

[0929] The terminal sends user requirements to the server. The requirements data is delivered to the server via network communication.

[0930] Input: User requirements entered in Step 8.

[0931] Output: Requirements data sent to the server.

[0932] Step 10: Search and display recipes

[0933] The server searches the database for a recipe that matches the user's requirements. If no suitable recipe is found, it uses an alternative recipe generation module to create a new recipe. It then generates optimized recipe information.

[0934] Input: Requirements data sent to the server.

[0935] Output: A recipe that meets the user requirements, or an alternative recipe that has been generated.

[0936] Step 11: Providing information to users

[0937] The terminal displays recipe information received from the server to the user. A GUI (Graphical User Interface) is used for this purpose.

[0938] Input: Recipe information sent from the server.

[0939] Output: Recipe information displayed on the terminal.

[0940] (Application Example 1)

[0941] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[0942] Modern food delivery services struggle to accommodate the diverse needs of users, particularly allergies and dietary preferences. Users have difficulty finding ingredients and recipes that suit their health and tastes, and as a result, obtaining suitable alternative recipes requires considerable time and effort. Furthermore, there are limited means of quickly ordering meals based on these alternative recipes. Thus, current food delivery systems face the challenge of not being able to fully meet the specific needs of users.

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

[0944] In this invention, the server includes means for collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes, means for receiving specific requirements from the user and presenting filtered and optimized recipes, means for collecting and storing the user's allergy information and food preferences, and means for enabling the ordering of dishes based on the alternative recipes based on the collected user information. As a result, the user can not only quickly obtain alternative recipes that suit their preferences and health condition, but also immediately order dishes through a food delivery service based on the generated alternative recipes.

[0945] A "food ingredient recipe database" is a collection of data containing multiple recipes stored on the internet or in dedicated databases.

[0946] "Recipe information" refers to detailed information about each recipe, such as the ingredient list, cooking instructions, and nutritional information.

[0947] A "substitute" refers to an alternative ingredient used to replace an ingredient in the original recipe, based on the specific requirements of a particular user.

[0948] "Simulation" is the process of experimenting with new recipes using the generated substitutes.

[0949] "Specific requirements" refer to individual conditions such as allergy information, food preferences, and nutritional requirements that users possess.

[0950] "Filtering" is the process of selecting recipe information or alternative recipes that meet specific requirements.

[0951] "Optimization" is the process of adjustment and improvement to extract and propose the recipe that best suits specific requirements.

[0952] A "user" refers to an individual or group that uses the system to obtain alternative recipes and then orders dishes based on those recipes.

[0953] "Allergy information" refers to information about foods that a user may be allergic to.

[0954] "Food preferences" refers to information about a user's preferences regarding food ingredients they particularly want to use or avoid.

[0955] An "order" is the act of a user requesting the purchase and delivery of a dish generated based on an alternative recipe.

[0956] A "server" refers to a computer system that collects, analyzes, optimizes, and provides recipe information.

[0957] The program for the system that realizes this invention is described in detail below.

[0958] System configuration and operation

[0959] This system primarily consists of three components: a server, a terminal, and a user. The server plays the main role of collecting and analyzing recipe information, generating alternative recipes, and providing information to users. The terminal is the interface where users input information and mediates communication with the server. The user is the entity that inputs specific conditions and selects and orders optimized alternative recipes.

[0960] 1. Server operation:

[0961] The server operates using the following procedure.

[0962] Recipe information is collected from a database of food ingredient recipes. The collected recipe information includes ingredient lists, cooking instructions, and nutritional information.

[0963] The collected recipe information is segmented and tagged using natural language processing (NLP), and the nutritional information for each ingredient is calculated by referring to a nutrition database.

[0964] Using an AI model, we generate alternative ingredients based on specific conditions and simulate new recipe combinations.

[0965] The system receives specific requirements from users (e.g., allergy information, food preferences) and presents filtered and optimized recipes.

[0966] Based on the collected user information, it will be possible to order dishes based on alternative recipes.

[0967] 2. Device operation:

[0968] Users input allergy information and food preferences via their devices. This information is sent to the server in JSON format.

[0969] 3. User Interface:

[0970] Users can receive alternative recipe suggestions by entering specific requirements using a terminal. For example, they might enter a specific requirement such as, "I have a dairy allergy, so I would like pasta without cream." The server then suggests alternative ingredients and presents an optimized recipe. Users can review the suggested recipe and order a meal based on it.

[0971] Hardware and software to be used

[0972] Server: Collects and analyzes recipe information, generates alternative recipes, and provides information. The server runs natural language processing models, a nutrition database, and AI models.

[0973] Device: A smartphone or tablet device used by the user, providing the user interface. The food delivery application is installed on it.

[0974] Examples of specific cases and prompt statements

[0975] For example, if a user has a dairy allergy and wants a vegan diet, they would enter the following through their device:

[0976] "I have a dairy allergy and would like a vegan diet. Please suggest pasta recipes that do not use cream."

[0977] This prompt is used by the server to generate alternative recipes in response to the user's request and suggest a specific recipe that is suitable for the user.

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

[0979] Step 1:

[0980] The user uses a terminal to input allergy information and food preferences. This information is sent to the server in JSON format. The input data includes specific allergy information (e.g., dairy allergy) and preferences (e.g., vegan). The server receives this data and stores it in its internal database.

[0981] Step 2:

[0982] The server collects recipe information from a database of food ingredient recipes. Specifically, it uses recipe websites on the internet and food ingredient database APIs to obtain recipe data including ingredient lists, cooking instructions, and nutritional information. This data is stored in JSON format or a relational database (e.g., MySQL).

[0983] Step 3:

[0984] The server collects recipe information and uses natural language processing (NLP) to segment and tag it. Each recipe's ingredients are classified as a separate item and tagged accordingly. The input data is the recipe information, and the output data is a list of tagged ingredients. During this process, NLP libraries (e.g., NLTK, spaCy) are used to analyze the data.

[0985] Step 4:

[0986] The server references a nutrition database and calculates the nutritional information for each ingredient. Based on a tagged list of ingredients, it retrieves the corresponding nutritional information from the nutrition database (e.g., USDA nutrition database) and adds the calculation results. The input data is the ingredient list, and the output data is the ingredient list with the nutritional information added.

[0987] Step 5:

[0988] The server uses an AI model to generate substitutes for each ingredient. Based on the user's specific requirements (e.g., dairy allergy, vegan), the AI ​​model (e.g., machine learning model, transformer) suggests appropriate substitute ingredients. The input data is a list of ingredients with nutritional information, and the output data is a list of substitute ingredients.

[0989] Step 6:

[0990] The server simulates new recipe combinations using substitute ingredients. Based on an AI model, it generates new recipes considering the balance of flavors and nutritional value of the dishes. The input data is a list of substitute ingredients, and the output data is the new recipe.

[0991] Step 7:

[0992] The system filters specific requirements entered by the user via their device and presents optimized recipes. The server searches for recipes that match the user's requirements and extracts the relevant recipes. The input data is the user's requirements, and the output data is the optimized recipe.

[0993] Step 8:

[0994] Based on user information collected by the server, it enables ordering of dishes based on alternative recipes. Users can view alternative recipes on their terminals and, if they like them, proceed directly to the order screen. Input data is the user's order request, and output data is order confirmation information.

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

[0996] This invention proposes a system for collecting, analyzing, and optimizing food recipe information, and providing alternative recipes tailored to the user's requirements and preferences. Specific embodiments thereof are described below.

[0997] System Configuration

[0998] This system is broadly composed of the following main components:

[0999] 1. Data Acquisition Module

[1000] 2. Data Analysis Module

[1001] 3. Alternative Recipe Generation Module

[1002] 4. Emotional Engine

[1003] 5. User Interface Module

[1004] Program processing

[1005] Data Acquisition Module

[1006] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[1007] Data Analysis Module

[1008] The data collected by the server is analyzed using natural language processing (NLP). Specifically, the following steps are taken:

[1009] The recipe information is divided, and each ingredient is tagged as a separate item.

[1010] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[1011] The analysis results extract detailed information such as ingredient types, nutritional value, and allergen information. This makes it easier to generate alternative recipes in the next step.

[1012] Alternative recipe generation module

[1013] The server uses an AI model (e.g., a machine learning model) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination in the dish.

[1014] For example, if a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest a dairy-free alternative (for example, soy cream) and generate an optimal recipe using it.

[1015] Emotional Engine

[1016] The emotion engine recognizes the user's emotions. This emotion engine analyzes the user's emotional state (e.g., joy, sadness, stress) using text input, voice, and facial recognition technology.

[1017] The recognized emotional information is reflected in the recipe suggestions. For example, if the user is feeling stressed, the system will suggest recipes using ingredients that have a relaxing effect.

[1018] User Interface Module

[1019] Users enter specific requirements (e.g., allergy information, requests for specific ingredients) via a chatbot. This input data is sent to the server through the device. For example, a user might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[1020] The emotion engine analyzes the user's input, facial expressions, and tone of voice to recognize the user's current emotional state. This emotional information is sent to the server and incorporated into the recipe recommendation process.

[1021] The server searches the database and filters the recipes based on the received requirements and emotional information. For example, when searching for pasta recipes using cream without dairy products, if the user is feeling down, it prioritizes displaying recipes that include ingredients that can lift their mood.

[1022] For example, if a user requests egg-free pancakes despite having an egg allergy, and the emotion engine simultaneously detects stress, the device sends this requirement and emotional information to the server. The server searches for and generates a suitable recipe, suggesting an optimized recipe that includes ingredients with relaxing effects (e.g., vanilla extract).

[1023] A text generation module is used to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might say, "This recipe uses banana puree instead of eggs and also includes vanilla extract for a relaxing effect."

[1024] This system allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge. Furthermore, it enables recipe suggestions tailored to the user's emotional state, providing more personalized support.

[1025] The following describes the processing flow.

[1026] Step 1:

[1027] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe, and this data is stored in the database.

[1028] Step 2:

[1029] The server analyzes the collected recipe information using natural language processing (NLP). Specifically, the recipe information is divided, and each ingredient is tagged as an independent item. For example, the ingredient "milk" is classified as "dairy products."

[1030] Step 3:

[1031] The server references a nutrition database and calculates the nutritional information for each ingredient. Specifically, it retrieves information such as calories, protein, fat, and carbohydrates for each ingredient and calculates the total nutritional value for each recipe.

[1032] Step 4:

[1033] The server uses an AI model to generate substitutes for each ingredient. For example, it suggests "soy milk" for "milk." It also lists alternative candidates for other ingredients and provides substitutes that meet the user's needs.

[1034] Step 5:

[1035] The server simulates new recipe combinations using the generated substitutes. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination. For example, it evaluates variations that use cashew cream instead of regular cream.

[1036] Step 6:

[1037] The user uses the chatbot function to enter specific requirements. For example, they might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[1038] Step 7:

[1039] The terminal analyzes the user's requirements and extracts specific conditions. The extracted conditions (e.g., "dairy allergy," "cream," "pasta") are then sent to the server.

[1040] Step 8:

[1041] The emotion engine recognizes the user's emotions. This involves a process of analyzing the user's emotional state (e.g., joy, sadness, stress) using text input, voice, and facial recognition technology.

[1042] Step 9:

[1043] The server filters the database based on user requirements and emotional information to find relevant recipes. For example, if searching for pasta recipes using cream without dairy products, and the user is feeling stressed, the server will prioritize displaying recipes that use ingredients with relaxing properties.

[1044] Step 10:

[1045] If a matching recipe is not found, the server uses an alternative recipe generation module to create a new alternative recipe. For example, it might generate a pasta recipe where cream is replaced with soy cream.

[1046] Step 11:

[1047] The server uses a text generation module to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might display: "This recipe uses soy cream instead of regular cream."

[1048] Step 12:

[1049] The device receives the best alternative recipe from the server and presents it to the user. The user can then review the presented recipe and learn about the specific cooking steps and ingredient list.

[1050] Step 13:

[1051] Once a user selects a suggested recipe, there are steps that provide additional cooking advice and customization options. In this way, users can easily find and execute the best alternative recipe.

[1052] (Example 2)

[1053] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[1054] Conventional food recipe provision systems struggle to suggest recipes that take into account the user's specific requirements and emotional state. As a result, users may be offered recipes that do not match their preferences or feelings, leading to decreased satisfaction. Furthermore, the lack of detailed data analysis regarding nutritional information and ingredient substitutes makes it difficult to suggest alternative recipes that take health and allergies into consideration.

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

[1056] In this invention, the server includes means for collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information using natural language processing and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes with a machine learning model, and means for receiving specific requirements and emotional states from the user, analyzing the emotional information using an emotion analysis engine, and presenting filtered and optimized recipes. This makes it possible to optimize recipes according to the user's specific requirements and emotional states, and to suggest alternative recipes that take health and allergies into consideration.

[1057] A "food ingredient recipe" is a description of information about food ingredients and how to prepare them.

[1058] A "database" is a system for systematically managing and retrieving large amounts of data.

[1059] "Recipe information" includes instructions on cooking, ingredients to be used, cooking procedures, and nutritional information.

[1060] "Natural language processing" is a technology that enables computers to understand, analyze, and generate human language.

[1061] "Analysis" is the process of examining collected data in detail and understanding its meaning and patterns.

[1062] A "substitute" is another material used to replace a particular material.

[1063] A "machine learning model" is an algorithm that learns patterns from a series of data and uses them to make predictions and classifications on new data.

[1064] "Simulation" is the process of imitating actual behavior by virtually reproducing processes and systems in the real world.

[1065] The "specific requirements" of a "user" refer to the specific requests or conditions that a user has regarding a recipe.

[1066] An "emotion analysis engine" is a technology that analyzes user input data (text, voice, images) to recognize their emotional state.

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

[1068] "Optimization" is the process of making adjustments to obtain the best possible results under specific conditions and constraints.

[1069] This invention is a system that collects, analyzes, and optimizes food recipe information, and provides alternative recipes tailored to the user's requirements and preferences. This system is broadly composed of the following main components:

[1070] 1. Data Acquisition Module

[1071] 2. Data Analysis Module

[1072] 3. Alternative Recipe Generation Module

[1073] 4. Emotional Engine

[1074] 5. User Interface Module

[1075] System Configuration

[1076] Data Acquisition Module

[1077] The server collects recipe information from recipe websites and ingredient databases on the internet. Specifically, it uses web scraping with libraries such as Python's BeautifulSoup and Scrapy to collect ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases (e.g., MySQL or PostgreSQL).

[1078] Data Analysis Module

[1079] The server analyzes the collected data using natural language processing (NLP). At this stage, NLP libraries (e.g., spaCy or NLTK) are used to tokenize recipe information and extract important keywords and ingredients. Nutritional information for each ingredient is also calculated by referencing a nutrition database (e.g., the USDA Nutrient Database).

[1080] Alternative recipe generation module

[1081] The server uses machine learning models (e.g., models built using TensorFlow or PyTorch) to generate alternative recipes based on user requirements and sentiment information. This includes the ability to suggest and simulate alternative ingredients. For example, if a user with a dairy allergy wants to make a pasta dish that uses cream, the server will suggest a dairy-free alternative (e.g., soy cream) and generate an optimal recipe using it.

[1082] Emotional Engine

[1083] An emotion engine recognizes the user's emotions. This is a technology that analyzes the user's text input, voice, and image data to recognize their emotional state (e.g., joy, sadness, stress). Examples include using the Google Cloud Vision API or IBM Watson Tone Analyzer.

[1084] User Interface Module

[1085] Users input specific requirements (e.g., allergy information, desired ingredients) via a chatbot. This input data is sent to the server through the device. Based on the received requirements and sentiment information, the server searches its database and filters for suitable recipes. The generated recipes are explained in natural language and presented to the user in an easy-to-understand format.

[1086] Examples of prompt statements

[1087] "I have a dairy allergy, but I'd like a pasta recipe that uses cream. I'm feeling a bit down today, so please let me know if you have any recipes that will cheer me up."

[1088] Examples

[1089] When a user enters a prompt into the chatbot, the device sends that input data to the server. The server first analyzes the recipe information collected by the data collection module using the data analysis module, and then recognizes the sentiment information using the sentiment engine. Subsequently, the alternative recipe generation module generates the optimal alternative recipe based on the user's requirements and sentiment. The generated recipe is then provided to the user via the user interface module. Through this series of processes, the user can efficiently obtain the optimal recipe that suits their requirements and sentiment.

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

[1091] Step 1: Data Collection

[1092] The server collects recipe information from multiple recipe websites and ingredient databases on the internet. This is done using web scraping libraries such as Python's BeautifulSoup and Scrapy.

[1093] Input: URL of the recipe website or API endpoint.

[1094] Data processing: The server retrieves HTML data from the web page and extracts the necessary information (e.g., ingredient list, cooking instructions, nutritional information, etc.).

[1095] Output: Recipe information stored in JSON format or a relational database.

[1096] Step 2: Data Analysis

[1097] The server analyzes the collected data using natural language processing (NLP). Specifically, recipe information is tokenized using an NLP library (e.g., spaCy, NLTK), and important keywords and tags are extracted.

[1098] Input: Recipe information saved in JSON format.

[1099] Data processing: The server tokenizes the ingredient list and tags each ingredient as an independent item. It also references a nutrition database (e.g., USDA Nutrient Database) to calculate the nutritional information for each ingredient.

[1100] Output: Data including analyzed recipe information, nutritional value, allergen information, etc.

[1101] Step 3: Emotion Analysis

[1102] The device acquires user input (text, voice, images) into the chatbot and sends it to the emotion engine. The emotion engine analyzes this data to recognize the user's emotional state.

[1103] Input: Text, audio, and image data from the user.

[1104] Data Processing: The emotion engine performs emotion analysis using NLP, facial recognition, and speech analysis technologies (e.g., Google Cloud Vision API and IBM Watson Tone Analyzer).

[1105] Output: User's emotional state (e.g., joy, sadness, stress).

[1106] Step 4: Generate alternative recipes

[1107] The server uses machine learning models (e.g., TensorFlow or PyTorch) to generate alternative recipes based on user requirements and sentiment information.

[1108] Input: Analyzed recipe information, nutritional data, user requirements, and emotional state.

[1109] Data Processing: The server considers user requirements and emotional information, suggesting alternative ingredients that are similar in nutritional value, allergen elimination, and taste characteristics. Machine learning models are used in this process to select the optimal ingredients.

[1110] Output: Optimized recipe using substitutes.

[1111] Step 5: Recipe suggestion

[1112] The server provides the generated alternative recipe to the user in an understandable format using a text generation module (e.g., natural language generation technology).

[1113] Input: Information on alternative recipes.

[1114] Data processing: The server generates recipe descriptions using natural language generation technology.

[1115] Output: The recipe description presented to the user.

[1116] Step 6: Presentation to the user

[1117] The device presents the generated recipe to the user.

[1118] Input: Recipe description sent from the server.

[1119] Data processing: The process by which the terminal formats recipe information and displays it in the user interface.

[1120] Output: The specific alternative recipe displayed on the user's screen.

[1121] Through these processing steps, users can efficiently obtain the optimal alternative recipe tailored to their requirements and emotional state.

[1122] (Application Example 2)

[1123] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[1124] While modern food recipe systems can accommodate specific user requirements such as allergies and dietary restrictions, systems that offer personalized recipe suggestions based on a user's emotional state still do not exist. In particular, meal suggestions that take into account emotions such as stress and joy are lacking, making it difficult to enhance users' psychological and emotional satisfaction. Furthermore, there are limitations to generating optimized alternative recipes, posing a challenge in quickly responding to diverse user needs.

[1125] The specific processing performed by the specific 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 collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes, means for recognizing the user's emotions and making recipe suggestions based on them, and means for inputting emotions and requirements through a user interface and providing optimized recipes. This makes it possible to provide optimized alternative recipes that correspond to the user's specific requirements and emotional state.

[1126] A "food recipe database" is a digital structure for systematically storing and managing food recipe information.

[1127] "Recipe information" refers to a dataset containing detailed information such as ingredient lists, cooking instructions, and nutritional information.

[1128] A "food substitute" is an ingredient that can be used in place of a specific ingredient and has similar nutritional value or taste characteristics.

[1129] A "simulation" is the process of using data and algorithms to mimic real-world situations and predict outcomes under hypothetical conditions.

[1130] "Specific user requirements" refer to detailed conditions desired by individual users, such as allergy information, food preferences, and nutritional needs.

[1131] "Filtering" is the process of selecting data that meets specific criteria from a large amount of data.

[1132] An "optimized recipe" is a recipe that has been tailored to the user's specific requirements and emotional state to be the most suitable for them.

[1133] "Means of recognizing emotions" refers to technologies and software used to analyze and identify a user's emotional state.

[1134] A "user interface" is an interactive environment for input and output that allows a user to interact with a system.

[1135] "Means of collection" refers to the functions and methods for obtaining recipe information from databases or the internet.

[1136] "Means of analysis" refers to the process of analyzing collected data and extracting meaningful information.

[1137] "Means of generating substitutes" refer to methods or algorithms for suggesting ingredients that can be used as substitutes for specific ingredients.

[1138] "Means of presentation" refers to methods and technologies for displaying user-optimized recipe information in an easy-to-understand format.

[1139] This invention is implemented as a system that provides food delivery services that respond to the specific requirements and emotional states of users. Specific embodiments of this system are described below.

[1140] System Configuration

[1141] This system includes the following main components.

[1142] 1. Data Acquisition Module

[1143] 2. Data Analysis Module

[1144] 3. Alternative Recipe Generation Module

[1145] 4. Emotion Recognition Engine

[1146] 5. User Interface Module

[1147] Data Acquisition Module

[1148] The server collects recipe information from online recipe and ingredient databases. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[1149] Data Analysis Module

[1150] The server analyzes the collected data using natural language processing (NLP). Specifically, it follows these steps:

[1151] The recipe information is divided, and each ingredient is tagged as a separate item.

[1152] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[1153] The analysis results extract detailed information such as the type of material, nutritional value, and allergen information.

[1154] Alternative recipe generation module

[1155] The server uses AI models (e.g., machine learning models) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This generates alternative recipes that are best suited to the user's specific requirements.

[1156] Emotion recognition engine

[1157] The emotion recognition engine recognizes the user's emotions using text input, voice, and facial recognition technology. The analyzed emotion information is then reflected in recipe suggestions. For example, if the user is feeling stressed, the engine will suggest recipes using ingredients that have a relaxing effect.

[1158] User Interface Module

[1159] The user enters specific requirements (e.g., allergy information, preference for certain ingredients) through the user interface. This input data is then sent to the server via the terminal.

[1160] For example, if a user enters "I have an egg allergy, but I want pancakes that don't use eggs," and the emotion recognition engine detects stress, the following prompt message will be generated.

[1161] Generate a recipe that meets the following requirements: Without eggs suitable for someone feeling stressed.

[1162] Sending this prompt to the server's AI model generates an optimized pancake recipe that includes vanilla extract, which has stress-reducing effects.

[1163] Examples

[1164] For example, if a user enters a request stating, "I have a dairy allergy, but I want to eat pasta with cream," the emotion recognition engine will recognize the user's emotional state and suggest a dairy-free alternative (e.g., soy cream). Furthermore, a recipe including ingredients that can improve the user's mood will be generated, tailored to their emotional state.

[1165] This allows users to quickly find the perfect meal tailored to their emotional state and specific requirements. The system can improve user satisfaction and provide a personalized food delivery service.

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

[1167] Step 1:

[1168] The server collects recipe information from recipe and ingredient databases on the internet. It uses HTTP requests to retrieve data from APIs and saves the retrieved data in JSON format. The input is the API URL, and the output is recipe data in JSON format.

[1169] Step 2:

[1170] The server analyzes the collected recipe data using a natural language processing (NLP) library. This process divides the recipe information and tags each ingredient as an independent item. It also refers to a nutrition database and calculates the nutritional information for each ingredient. The input is recipe data in JSON format, and the output is the analyzed recipe data and nutritional information.

[1171] Step 3:

[1172] The server receives specific requirements and sentiment information entered by the user. It collects requirements entered by the user through the user interface and sentiment information recognized by the sentiment recognition engine. The input consists of the user's requirements and sentiment information, while the output consists of the received requirements and sentiment information.

[1173] Step 4:

[1174] The emotion recognition engine analyzes user input text and voice to recognize the user's emotional state. Specifically, it uses speech recognition software and facial recognition technology to evaluate the user's emotions. The input is the user's text and voice data, and the output is the recognized emotion information.

[1175] Step 5:

[1176] The server uses an AI model to generate alternative recipes based on analyzed recipe data, user requirements, and sentiment information. This process generates the optimal recipe by combining alternative ingredients that meet the user's requirements (e.g., allergy information). The input is the analyzed recipe data, user requirements, and sentiment information, and the output is the generated alternative recipe.

[1177] Step 6:

[1178] The server filters and optimizes the generated alternative recipes. During this process, it selects the optimal recipe, taking into account factors such as the nutritional value of the ingredients used and the user's emotional state. The input is the generated alternative recipe, and the output is the optimized, best-in-class recipe.

[1179] Step 7:

[1180] The user interface presents optimized recipe information to the user. A text generation module is used to generate detailed recipe descriptions for easy viewing. The input is optimized recipe information, and the output is a text-based recipe description for display to the user.

[1181] As a concrete example of its operation, if a user enters a request such as "I have an egg allergy, but I would like pancakes that do not contain eggs," and the emotion recognition engine detects stress, the following prompt message will be generated.

[1182] Generate a recipe that meets the following requirements: Without eggs suitable for someone feeling stressed.

[1183] By sending this prompt to the AI ​​model, an optimized pancake recipe containing vanilla extract, known for its stress-reducing effects, is generated. Finally, the user is shown through the user interface the message, "This recipe uses banana puree instead of eggs and also includes relaxing vanilla extract."

[1184] The specific processing unit 290 transmits the result of the specific processing to the headset terminal 314. In the headset terminal 314, the control unit 46A causes the speaker 240 and display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

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

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

[1187] [Fourth Embodiment]

[1188] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[1189] As shown in Figure 7, the data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

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

[1191] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

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

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

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

[1195] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[1196] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

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

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

[1199] In robot 414, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

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

[1201] The system of the present invention collects, analyzes, and optimizes food recipe information, and provides alternative recipes tailored to the user's requirements. Specific embodiments are described below.

[1202] System Configuration

[1203] This system is broadly composed of the following main components:

[1204] 1. Data Acquisition Module

[1205] 2. Data Analysis Module

[1206] 3. Alternative Recipe Generation Module

[1207] 4. User Interface Module

[1208] Program processing

[1209] Data Acquisition Module

[1210] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[1211] Data Analysis Module

[1212] The data collected by the server is analyzed using natural language processing (NLP). Specifically, the following steps are taken:

[1213] The recipe information is divided, and each ingredient is tagged as a separate item.

[1214] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[1215] The analysis results extract detailed information such as ingredient types, nutritional value, and allergen information. This makes it easier to generate alternative recipes in the next step.

[1216] Alternative recipe generation module

[1217] The server uses an AI model (e.g., a machine learning model) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination in the dish.

[1218] For example, if a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest a dairy-free alternative (for example, soy cream) and generate an optimal recipe using it.

[1219] User Interface Module

[1220] Users enter specific requirements (e.g., allergy information, requests for specific ingredients) via a chatbot. This input data is then sent to the server via the device.

[1221] The server searches the database based on the received requirements and filters the recipes accordingly. For example, in response to a request from a user with a dairy allergy, it searches for and displays recipes that do not use dairy products.

[1222] If a recipe is not found, the server uses an alternative recipe generation module to construct a new recipe and presents the optimized recipe to the user using a text generation module that explains it in natural language.

[1223] For example, if a user requests "I have an egg allergy, but I want pancakes without eggs," the device sends this request to the server, which then searches for and generates a suitable recipe. The generated recipe is then displayed to the user in a detailed explanation format.

[1224] This system allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge. The system aims to ensure a stable food supply and can meet the diverse needs of users.

[1225] The following describes the processing flow.

[1226] Step 1:

[1227] The server collects recipe information from recipe websites and ingredient databases on the internet. Specifically, it uses scraping tools to obtain recipe titles, ingredients, cooking instructions, and nutritional information, and stores them in a database.

[1228] Step 2:

[1229] The server analyzes the collected recipe information. Natural language processing (NLP) is used to split and tag the ingredient list and cooking instructions for each recipe. For example, the ingredient "milk" is classified as "dairy products".

[1230] Step 3:

[1231] The server references a nutrition database and calculates nutritional information such as calories, protein, fat, and carbohydrates for each ingredient. Based on this information, it calculates the total nutritional value of each recipe.

[1232] Step 4:

[1233] The server uses an AI model to generate substitutes for each ingredient. For example, it creates a specific list of alternatives, such as suggesting soy milk instead of cow's milk.

[1234] Step 5:

[1235] The server simulates new recipe combinations using the generated substitutes. The simulation considers factors such as the balance of flavors, nutritional value, and allergen elimination. For example, it evaluates variations that use cashew cream instead of regular cream.

[1236] Step 6:

[1237] The user uses the chatbot function to enter specific requirements. For example, they might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[1238] Step 7:

[1239] The device analyzes the user's requirements and extracts specific conditions (e.g., "dairy allergy," "cream," "pasta"). The extracted results are then sent to the server.

[1240] Step 8:

[1241] The server filters the database based on the user's requirements and searches for relevant recipes. For example, it might search for pasta recipes that use cream without dairy products.

[1242] Step 9:

[1243] If a matching recipe is not found, the server will use an alternative recipe generation module to create a new alternative recipe. For example, it might generate a pasta recipe where cream is replaced with soy cream.

[1244] Step 10:

[1245] The server uses a text generation module to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might display, "This recipe uses soy cream instead of regular cream."

[1246] Step 11:

[1247] The device receives the best alternative recipe from the server and presents it to the user. The user can then review the presented recipe and learn about the specific cooking steps and ingredient list.

[1248] (Example 1)

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

[1250] Conventional food recipe systems have struggled to easily generate and optimize alternative recipes to meet specific user requirements. Furthermore, manual recipe collection and analysis are time-consuming, preventing users from quickly obtaining their desired alternative recipes. Additionally, recipe generation that considers the nutritional and allergen information of individual ingredients is insufficient.

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

[1252] In this invention, the server includes means for collecting recipe information from multiple websites that provide recipe information via a communication network; means for analyzing the collected recipe information using natural language processing technology and tagging each ingredient as an independent item; means for referring to a nutrition database and calculating nutritional information for each ingredient; means for generating substitutes for each ingredient using a machine learning model; means for simulating new recipes using the generated substitutes; and means for receiving specific requirements via a user terminal and presenting filtered and optimized recipes. This makes it possible to provide alternative recipes that quickly and appropriately respond to the user's specific requirements.

[1253] A "communication network" is a collection of technical means and protocols used to exchange data, and refers to wide-area communication systems, including the Internet.

[1254] "Recipe information" refers to data containing detailed information about how to prepare a dish, including a specific list of ingredients, cooking steps, and nutritional information.

[1255] A "website" refers to a collection of online pages that provide information accessible via the internet.

[1256] "Natural language processing technology" refers to the technology that enables computers to understand, analyze, generate, and respond to human language, including tasks such as text segmentation, tagging, and semantic understanding.

[1257] "Tagging" is the process of classifying data into specific categories or attributes and adding annotations or labels to make it identifiable.

[1258] A "nutrition database" is a database that collects information on the nutritional components of food, including data on nutrients such as energy, vitamins, and minerals for each food item.

[1259] A "machine learning model" is a type of artificial intelligence that learns patterns based on data and performs tasks such as prediction, classification, and generation.

[1260] A "substitute" is an ingredient used in place of the original ingredient, and is selected to have similar nutritional value and taste characteristics.

[1261] A "simulation" is a trial or test conducted under a virtual environment or conditions, a process of observing the results by imitating a real-world situation.

[1262] A "user terminal" refers to a device that a user directly operates, and includes personal computers, smartphones, tablets, and other similar devices.

[1263] "Requirements" refer to requests or preferences submitted by users based on specific conditions or desires, and include specific needs such as allergy information or the use of certain ingredients.

[1264] "Filtering" refers to the process of selecting data based on specific criteria and extracting relevant information.

[1265] "Optimization" refers to adjusting a system or process to achieve the best results under specific goals and constraints.

[1266] This invention is a system for users to quickly and effectively generate and provide alternative recipes based on specific requirements. This system mainly consists of a server, user terminals, and a database connected via a communication network.

[1267] System Configuration

[1268] The server is connected to the internet and is responsible for collecting recipe information from multiple recipe websites. Specifically, it uses the Python requests library to access specified websites and uses BeautifulSoup to scrape the necessary information (ingredients list, cooking instructions, nutritional information) from the web pages. The collected data is stored in JSON format or in a relational database such as MySQL or PostgreSQL.

[1269] Specific example: The server regularly collects ingredient lists, cooking instructions, and nutritional information from AllRecipes and Cookpad, and stores them in a database, ensuring that the latest recipe information is always updated.

[1270] Furthermore, the server also plays a role in analyzing the collected recipe information using natural language processing (NLP) techniques. Specifically, it uses Python NLP libraries (such as NLTK and SpaCy) to analyze the recipe text and tag each ingredient as a separate item. It also refers to nutrition databases (e.g., the USDA Food Database) to calculate the nutritional information for each ingredient.

[1271] Specific example: If a recipe includes "tomatoes, onions, and garlic," tags such as "vegetable" and "spice" will be assigned to each ingredient, and nutritional information will be calculated.

[1272] In the next stage, the server uses a machine learning model (e.g., Scikit-learn's RandomForestClassifier) ​​to generate substitutes for each ingredient from the collected data. In this process, ingredients with similar nutritional value and flavor characteristics are suggested. New recipes using the generated substitutes are then simulated by the AI ​​model. The simulation results are optimized, taking into account factors such as the balance of flavors, nutritional value, and allergen elimination.

[1273] Specific example: If a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest soy milk cream as an alternative and provide an optimal recipe using it.

[1274] Through the user's terminal, the user enters specific requirements (for example, allergy information or a desire to use specific ingredients) into the chatbot. The terminal sends these requirements to the server, which searches the database based on the received requirements. If a suitable recipe is not found, the server uses an alternative recipe generation module to construct a new recipe and provides the user with recipe information optimized for them.

[1275] Specific example: If a user requests "I have an egg allergy, but I want pancakes without eggs," that requirement is sent from the device to the server. The server searches for and generates a suitable recipe and presents it to the user.

[1276] Example of a prompt

[1277] Data collection prompt: "Collect recipe information, including ingredient lists, cooking instructions, and nutritional information, from recipe websites on the internet and save it in JSON format."

[1278] Data analysis prompt: "Analyze the collected recipe data, tag each ingredient, calculate nutritional information, and save it in JSON format."

[1279] Prompt for generating alternative recipes: "Use an AI model to generate dairy-free pasta recipes for users with dairy allergies."

[1280] User interface prompt: "Based on the user's requirements (e.g., egg allergy), please provide and display the appropriate alternative recipe in a detailed format."

[1281] Through the above means, it becomes possible to provide a system that allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge.

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

[1283] Step 1: Data Collection

[1284] The server connects to the internet and accesses multiple recipe websites. This connection uses the Python requests library to send HTTP requests. The server retrieves HTML documents from each website. Specifically, it accesses web pages using the requests.get(URL) method and retrieves the HTML data received as a response.

[1285] Input: URLs of multiple specified recipe websites.

[1286] Output: HTML document corresponding to each URL.

[1287] Step 2: Web scraping

[1288] The server uses BeautifulSoup to parse and extract HTML documents. Specifically, it uses `soup = BeautifulSoup(html, 'html.parser')` to extract the ingredient list, cooking instructions, and nutritional information for each recipe.

[1289] Input: The HTML document obtained in Step 1.

[1290] Output: Data including recipe ingredient list, cooking instructions, and nutritional information.

[1291] Step 3: Save Data

[1292] The server saves the extracted recipe data in JSON format or a relational database. For example, it connects to a MySQL database and executes an SQL query like INSERT INTO recipes (title, ingredients, instructions, nutrition) VALUES (...).

[1293] Input: Recipe data extracted in Step 2.

[1294] Output: Recipe information stored in a JSON file or database.

[1295] Step 4: Natural Language Processing (NLP)

[1296] The server analyzes the collected and stored recipe data using a Python NLP library (e.g., NLTK or SpaCy). Specifically, it splits the recipe text and tags each ingredient as an independent item. The library is loaded like this: nlp = spacy.load('en_core_web_sm') and the analysis is performed with doc = nlp(recipe_text).

[1297] Input: Recipe text retrieved from the database.

[1298] Output: Data for each tagged material.

[1299] Step 5: Calculate nutritional information

[1300] The server references a nutrition database (e.g., the USDA Food Database) and calculates the nutritional information for each tagged ingredient. Specifically, it calculates the energy, vitamins, minerals, etc. values ​​for each ingredient and sets it up as follows: `nutrition_info = calculate_nutrition(ingredient)`.

[1301] Input: Material data tagged in Step 4.

[1302] Output: Recipe data with added nutritional information.

[1303] Step 6: Generating a substitute for the material

[1304] The server uses a machine learning model (for example, Scikit-learn's RandomForestClassifier) ​​to generate substitutes for each ingredient. For example, it might substitute "dairy products" with "soy cream." Substitutes are suggested using a method like model.predict(alternative_ingredient).

[1305] Input: Recipe data with nutritional information added in Step 5.

[1306] Output: List of materials for which alternatives have been suggested.

[1307] Step 7: Simulation of alternative recipes

[1308] The server simulates a new recipe using the generated substitute ingredients. The simulation uses an AI model that considers factors such as flavor balance, nutritional value, and allergen elimination. The simulation is executed using a command like `simulate_recipe(new_ingredients)`.

[1309] Input: The list of alternatives suggested in Step 6.

[1310] Output: A simulated new recipe.

[1311] Step 8: Enter user requirements

[1312] The user enters specific requirements into the chatbot via their device. For example, they might type, "I have an egg allergy, so I'd like egg-free pancakes."

[1313] Input: User requirements (e.g., allergy information).

[1314] Output: Requirements data from the terminal to the server.

[1315] Step 9: Submitting Requirements

[1316] The terminal sends user requirements to the server. The requirements data is delivered to the server via network communication.

[1317] Input: User requirements entered in Step 8.

[1318] Output: Requirements data sent to the server.

[1319] Step 10: Search and display recipes

[1320] The server searches the database for a recipe that matches the user's requirements. If no suitable recipe is found, it uses an alternative recipe generation module to create a new recipe. It then generates optimized recipe information.

[1321] Input: Requirements data sent to the server.

[1322] Output: A recipe that meets the user requirements, or an alternative recipe that has been generated.

[1323] Step 11: Providing information to users

[1324] The terminal displays recipe information received from the server to the user. A GUI (Graphical User Interface) is used for this purpose.

[1325] Input: Recipe information sent from the server.

[1326] Output: Recipe information displayed on the terminal.

[1327] (Application Example 1)

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

[1329] Modern food delivery services struggle to accommodate the diverse needs of users, particularly allergies and dietary preferences. Users have difficulty finding ingredients and recipes that suit their health and tastes, and as a result, obtaining suitable alternative recipes requires considerable time and effort. Furthermore, there are limited means of quickly ordering meals based on these alternative recipes. Thus, current food delivery systems face the challenge of not being able to fully meet the specific needs of users.

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

[1331] In this invention, the server includes means for collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes, means for receiving specific requirements from the user and presenting filtered and optimized recipes, means for collecting and storing the user's allergy information and food preferences, and means for enabling the ordering of dishes based on the alternative recipes based on the collected user information. As a result, the user can not only quickly obtain alternative recipes that suit their preferences and health condition, but also immediately order dishes through a food delivery service based on the generated alternative recipes.

[1332] A "food ingredient recipe database" is a collection of data containing multiple recipes stored on the internet or in dedicated databases.

[1333] "Recipe information" refers to detailed information about each recipe, such as the ingredient list, cooking instructions, and nutritional information.

[1334] A "substitute" refers to an alternative ingredient used to replace an ingredient in the original recipe, based on the specific requirements of a particular user.

[1335] "Simulation" is the process of experimenting with new recipes using the generated substitutes.

[1336] "Specific requirements" refer to individual conditions such as allergy information, food preferences, and nutritional requirements that users possess.

[1337] "Filtering" is the process of selecting recipe information or alternative recipes that meet specific requirements.

[1338] "Optimization" is the process of adjustment and improvement to extract and propose the recipe that best suits specific requirements.

[1339] A "user" refers to an individual or group that uses the system to obtain alternative recipes and then orders dishes based on those recipes.

[1340] "Allergy information" refers to information about foods that a user may be allergic to.

[1341] "Food preferences" refers to information about a user's preferences regarding food ingredients they particularly want to use or avoid.

[1342] An "order" is the act of a user requesting the purchase and delivery of a dish generated based on an alternative recipe.

[1343] A "server" refers to a computer system that collects, analyzes, optimizes, and provides recipe information.

[1344] The program for the system that realizes this invention is described in detail below.

[1345] System configuration and operation

[1346] This system primarily consists of three components: a server, a terminal, and a user. The server plays the main role of collecting and analyzing recipe information, generating alternative recipes, and providing information to users. The terminal is the interface where users input information and mediates communication with the server. The user is the entity that inputs specific conditions and selects and orders optimized alternative recipes.

[1347] 1. Server operation:

[1348] The server operates using the following procedure.

[1349] Recipe information is collected from a database of food ingredient recipes. The collected recipe information includes ingredient lists, cooking instructions, and nutritional information.

[1350] The collected recipe information is segmented and tagged using natural language processing (NLP), and the nutritional information for each ingredient is calculated by referring to a nutrition database.

[1351] Using an AI model, we generate alternative ingredients based on specific conditions and simulate new recipe combinations.

[1352] The system receives specific requirements from users (e.g., allergy information, food preferences) and presents filtered and optimized recipes.

[1353] Based on the collected user information, it will be possible to order dishes based on alternative recipes.

[1354] 2. Device operation:

[1355] Users input allergy information and food preferences via their devices. This information is sent to the server in JSON format.

[1356] 3. User Interface:

[1357] Users can receive alternative recipe suggestions by entering specific requirements using a terminal. For example, they might enter a specific requirement such as, "I have a dairy allergy, so I would like pasta without cream." The server then suggests alternative ingredients and presents an optimized recipe. Users can review the suggested recipe and order a meal based on it.

[1358] Hardware and software to be used

[1359] Server: Collects and analyzes recipe information, generates alternative recipes, and provides information. The server runs natural language processing models, a nutrition database, and AI models.

[1360] Device: A smartphone or tablet device used by the user, providing the user interface. The food delivery application is installed on it.

[1361] Examples of specific cases and prompt statements

[1362] For example, if a user has a dairy allergy and wants a vegan diet, they would enter the following through their device:

[1363] "I have a dairy allergy and would like a vegan diet. Please suggest pasta recipes that do not use cream."

[1364] This prompt is used by the server to generate alternative recipes in response to the user's request and suggest a specific recipe that is suitable for the user.

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

[1366] Step 1:

[1367] The user uses a terminal to input allergy information and food preferences. This information is sent to the server in JSON format. The input data includes specific allergy information (e.g., dairy allergy) and preferences (e.g., vegan). The server receives this data and stores it in its internal database.

[1368] Step 2:

[1369] The server collects recipe information from a database of food ingredient recipes. Specifically, it uses recipe websites on the internet and food ingredient database APIs to obtain recipe data including ingredient lists, cooking instructions, and nutritional information. This data is stored in JSON format or a relational database (e.g., MySQL).

[1370] Step 3:

[1371] The server collects recipe information and uses natural language processing (NLP) to segment and tag it. Each recipe's ingredients are classified as a separate item and tagged accordingly. The input data is the recipe information, and the output data is a list of tagged ingredients. During this process, NLP libraries (e.g., NLTK, spaCy) are used to analyze the data.

[1372] Step 4:

[1373] The server references a nutrition database and calculates the nutritional information for each ingredient. Based on a tagged list of ingredients, it retrieves the corresponding nutritional information from the nutrition database (e.g., USDA nutrition database) and adds the calculation results. The input data is the ingredient list, and the output data is the ingredient list with the nutritional information added.

[1374] Step 5:

[1375] The server uses an AI model to generate substitutes for each ingredient. Based on the user's specific requirements (e.g., dairy allergy, vegan), the AI ​​model (e.g., machine learning model, transformer) suggests appropriate substitute ingredients. The input data is a list of ingredients with nutritional information, and the output data is a list of substitute ingredients.

[1376] Step 6:

[1377] The server simulates new recipe combinations using substitute ingredients. Based on an AI model, it generates new recipes considering the balance of flavors and nutritional value of the dishes. The input data is a list of substitute ingredients, and the output data is the new recipe.

[1378] Step 7:

[1379] The system filters specific requirements entered by the user via their device and presents optimized recipes. The server searches for recipes that match the user's requirements and extracts the relevant recipes. The input data is the user's requirements, and the output data is the optimized recipe.

[1380] Step 8:

[1381] Based on user information collected by the server, it enables ordering of dishes based on alternative recipes. Users can view alternative recipes on their terminals and, if they like them, proceed directly to the order screen. Input data is the user's order request, and output data is order confirmation information.

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

[1383] This invention proposes a system for collecting, analyzing, and optimizing food recipe information, and providing alternative recipes tailored to the user's requirements and preferences. Specific embodiments thereof are described below.

[1384] System Configuration

[1385] This system is broadly composed of the following main components:

[1386] 1. Data Acquisition Module

[1387] 2. Data Analysis Module

[1388] 3. Alternative Recipe Generation Module

[1389] 4. Emotional Engine

[1390] 5. User Interface Module

[1391] Program processing

[1392] Data Acquisition Module

[1393] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[1394] Data Analysis Module

[1395] The data collected by the server is analyzed using natural language processing (NLP). Specifically, the following steps are taken:

[1396] The recipe information is divided, and each ingredient is tagged as a separate item.

[1397] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[1398] The analysis results extract detailed information such as ingredient types, nutritional value, and allergen information. This makes it easier to generate alternative recipes in the next step.

[1399] Alternative recipe generation module

[1400] The server uses an AI model (e.g., a machine learning model) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination in the dish.

[1401] For example, if a user with a dairy allergy wants to make a pasta dish using cream, the server will suggest a dairy-free alternative (for example, soy cream) and generate an optimal recipe using it.

[1402] Emotional Engine

[1403] The emotion engine recognizes the user's emotions. This emotion engine analyzes the user's emotional state (e.g., joy, sadness, stress) using text input, voice, and facial recognition technology.

[1404] The recognized emotional information is reflected in the recipe suggestions. For example, if the user is feeling stressed, the system will suggest recipes using ingredients that have a relaxing effect.

[1405] User Interface Module

[1406] Users enter specific requirements (e.g., allergy information, requests for specific ingredients) via a chatbot. This input data is sent to the server through the device. For example, a user might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[1407] The emotion engine analyzes the user's input, facial expressions, and tone of voice to recognize the user's current emotional state. This emotional information is sent to the server and incorporated into the recipe recommendation process.

[1408] The server searches the database and filters the recipes based on the received requirements and emotional information. For example, when searching for pasta recipes using cream without dairy products, if the user is feeling down, it prioritizes displaying recipes that include ingredients that can lift their mood.

[1409] For example, if a user requests egg-free pancakes despite having an egg allergy, and the emotion engine simultaneously detects stress, the device sends this requirement and emotional information to the server. The server searches for and generates a suitable recipe, suggesting an optimized recipe that includes ingredients with relaxing effects (e.g., vanilla extract).

[1410] A text generation module is used to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might say, "This recipe uses banana puree instead of eggs and also includes vanilla extract for a relaxing effect."

[1411] This system allows users to efficiently and quickly obtain appropriate alternative recipes without requiring specialized knowledge. Furthermore, it enables recipe suggestions tailored to the user's emotional state, providing more personalized support.

[1412] The following describes the processing flow.

[1413] Step 1:

[1414] The server collects recipe information from recipe websites and ingredient databases on the internet. This includes ingredient lists, cooking instructions, and nutritional information for each recipe, and this data is stored in the database.

[1415] Step 2:

[1416] The server analyzes the collected recipe information using natural language processing (NLP). Specifically, the recipe information is divided, and each ingredient is tagged as an independent item. For example, the ingredient "milk" is classified as "dairy products."

[1417] Step 3:

[1418] The server references a nutrition database and calculates the nutritional information for each ingredient. Specifically, it retrieves information such as calories, protein, fat, and carbohydrates for each ingredient and calculates the total nutritional value for each recipe.

[1419] Step 4:

[1420] The server uses an AI model to generate substitutes for each ingredient. For example, it suggests "soy milk" for "milk." It also lists alternative candidates for other ingredients and provides substitutes that meet the user's needs.

[1421] Step 5:

[1422] The server simulates new recipe combinations using the generated substitutes. This simulation takes into account factors such as the balance of flavors, nutritional value, and allergen elimination. For example, it evaluates variations that use cashew cream instead of regular cream.

[1423] Step 6:

[1424] The user uses the chatbot function to enter specific requirements. For example, they might enter, "I have a dairy allergy, but I'd like a pasta recipe that uses cream."

[1425] Step 7:

[1426] The terminal analyzes the user's requirements and extracts specific conditions. The extracted conditions (e.g., "dairy allergy," "cream," "pasta") are then sent to the server.

[1427] Step 8:

[1428] The emotion engine recognizes the user's emotions. This involves a process of analyzing the user's emotional state (e.g., joy, sadness, stress) using text input, voice, and facial recognition technology.

[1429] Step 9:

[1430] The server filters the database based on user requirements and emotional information to find relevant recipes. For example, if searching for pasta recipes using cream without dairy products, and the user is feeling stressed, the server will prioritize displaying recipes that use ingredients with relaxing properties.

[1431] Step 10:

[1432] If a matching recipe is not found, the server uses an alternative recipe generation module to create a new alternative recipe. For example, it might generate a pasta recipe where cream is replaced with soy cream.

[1433] Step 11:

[1434] The server uses a text generation module to explain the generated recipe in natural language, providing it to the user in an easy-to-understand format. For example, it might display: "This recipe uses soy cream instead of regular cream."

[1435] Step 12:

[1436] The device receives the best alternative recipe from the server and presents it to the user. The user can then review the presented recipe and learn about the specific cooking steps and ingredient list.

[1437] Step 13:

[1438] Once a user selects a suggested recipe, there are steps that provide additional cooking advice and customization options. In this way, users can easily find and execute the best alternative recipe.

[1439] (Example 2)

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

[1441] Conventional food recipe provision systems struggle to suggest recipes that take into account the user's specific requirements and emotional state. As a result, users may be offered recipes that do not match their preferences or feelings, leading to decreased satisfaction. Furthermore, the lack of detailed data analysis regarding nutritional information and ingredient substitutes makes it difficult to suggest alternative recipes that take health and allergies into consideration.

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

[1443] In this invention, the server includes means for collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information using natural language processing and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes with a machine learning model, and means for receiving specific requirements and emotional states from the user, analyzing the emotional information using an emotion analysis engine, and presenting filtered and optimized recipes. This makes it possible to optimize recipes according to the user's specific requirements and emotional states, and to suggest alternative recipes that take health and allergies into consideration.

[1444] A "food ingredient recipe" is a description of information about food ingredients and how to prepare them.

[1445] A "database" is a system for systematically managing and retrieving large amounts of data.

[1446] "Recipe information" includes instructions on cooking, ingredients to be used, cooking procedures, and nutritional information.

[1447] "Natural language processing" is a technology that enables computers to understand, analyze, and generate human language.

[1448] "Analysis" is the process of examining collected data in detail and understanding its meaning and patterns.

[1449] A "substitute" is another material used to replace a particular material.

[1450] A "machine learning model" is an algorithm that learns patterns from a series of data and uses them to make predictions and classifications on new data.

[1451] "Simulation" is the process of imitating actual behavior by virtually reproducing processes and systems in the real world.

[1452] The "specific requirements" of a "user" refer to the specific requests or conditions that a user has regarding a recipe.

[1453] An "emotion analysis engine" is a technology that analyzes user input data (text, voice, images) to recognize their emotional state.

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

[1455] "Optimization" is the process of making adjustments to obtain the best possible results under specific conditions and constraints.

[1456] This invention is a system that collects, analyzes, and optimizes food recipe information, and provides alternative recipes tailored to the user's requirements and preferences. This system is broadly composed of the following main components:

[1457] 1. Data Acquisition Module

[1458] 2. Data Analysis Module

[1459] 3. Alternative Recipe Generation Module

[1460] 4. Emotional Engine

[1461] 5. User Interface Module

[1462] System Configuration

[1463] Data Acquisition Module

[1464] The server collects recipe information from recipe websites and ingredient databases on the internet. Specifically, it uses web scraping with libraries such as Python's BeautifulSoup and Scrapy to collect ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases (e.g., MySQL or PostgreSQL).

[1465] Data Analysis Module

[1466] The server analyzes the collected data using natural language processing (NLP). At this stage, NLP libraries (e.g., spaCy or NLTK) are used to tokenize recipe information and extract important keywords and ingredients. Nutritional information for each ingredient is also calculated by referencing a nutrition database (e.g., the USDA Nutrient Database).

[1467] Alternative recipe generation module

[1468] The server uses machine learning models (e.g., models built using TensorFlow or PyTorch) to generate alternative recipes based on user requirements and sentiment information. This includes the ability to suggest and simulate alternative ingredients. For example, if a user with a dairy allergy wants to make a pasta dish that uses cream, the server will suggest a dairy-free alternative (e.g., soy cream) and generate an optimal recipe using it.

[1469] Emotional Engine

[1470] An emotion engine recognizes the user's emotions. This is a technology that analyzes the user's text input, voice, and image data to recognize their emotional state (e.g., joy, sadness, stress). Examples include using the Google Cloud Vision API or IBM Watson Tone Analyzer.

[1471] User Interface Module

[1472] Users input specific requirements (e.g., allergy information, desired ingredients) via a chatbot. This input data is sent to the server through the device. Based on the received requirements and sentiment information, the server searches its database and filters for suitable recipes. The generated recipes are explained in natural language and presented to the user in an easy-to-understand format.

[1473] Examples of prompt statements

[1474] "I have a dairy allergy, but I'd like a pasta recipe that uses cream. I'm feeling a bit down today, so please let me know if you have any recipes that will cheer me up."

[1475] Examples

[1476] When a user enters a prompt into the chatbot, the device sends that input data to the server. The server first analyzes the recipe information collected by the data collection module using the data analysis module, and then recognizes the sentiment information using the sentiment engine. Subsequently, the alternative recipe generation module generates the optimal alternative recipe based on the user's requirements and sentiment. The generated recipe is then provided to the user via the user interface module. Through this series of processes, the user can efficiently obtain the optimal recipe that suits their requirements and sentiment.

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

[1478] Step 1: Data Collection

[1479] The server collects recipe information from multiple recipe websites and ingredient databases on the internet. This is done using web scraping libraries such as Python's BeautifulSoup and Scrapy.

[1480] Input: URL of the recipe website or API endpoint.

[1481] Data processing: The server retrieves HTML data from the web page and extracts the necessary information (e.g., ingredient list, cooking instructions, nutritional information, etc.).

[1482] Output: Recipe information stored in JSON format or a relational database.

[1483] Step 2: Data Analysis

[1484] The server analyzes the collected data using natural language processing (NLP). Specifically, recipe information is tokenized using an NLP library (e.g., spaCy, NLTK), and important keywords and tags are extracted.

[1485] Input: Recipe information saved in JSON format.

[1486] Data processing: The server tokenizes the ingredient list and tags each ingredient as an independent item. It also references a nutrition database (e.g., USDA Nutrient Database) to calculate the nutritional information for each ingredient.

[1487] Output: Data including analyzed recipe information, nutritional value, allergen information, etc.

[1488] Step 3: Emotion Analysis

[1489] The device acquires user input (text, voice, images) into the chatbot and sends it to the emotion engine. The emotion engine analyzes this data to recognize the user's emotional state.

[1490] Input: Text, audio, and image data from the user.

[1491] Data Processing: The emotion engine performs emotion analysis using NLP, facial recognition, and speech analysis technologies (e.g., Google Cloud Vision API and IBM Watson Tone Analyzer).

[1492] Output: User's emotional state (e.g., joy, sadness, stress).

[1493] Step 4: Generate alternative recipes

[1494] The server uses machine learning models (e.g., TensorFlow or PyTorch) to generate alternative recipes based on user requirements and sentiment information.

[1495] Input: Analyzed recipe information, nutritional data, user requirements, and emotional state.

[1496] Data Processing: The server considers user requirements and emotional information, suggesting alternative ingredients that are similar in nutritional value, allergen elimination, and taste characteristics. Machine learning models are used in this process to select the optimal ingredients.

[1497] Output: Optimized recipe using substitutes.

[1498] Step 5: Recipe suggestion

[1499] The server provides the generated alternative recipe to the user in an understandable format using a text generation module (e.g., natural language generation technology).

[1500] Input: Information on alternative recipes.

[1501] Data processing: The server generates recipe descriptions using natural language generation technology.

[1502] Output: The recipe description presented to the user.

[1503] Step 6: Presentation to the user

[1504] The device presents the generated recipe to the user.

[1505] Input: Recipe description sent from the server.

[1506] Data processing: The process by which the terminal formats recipe information and displays it in the user interface.

[1507] Output: The specific alternative recipe displayed on the user's screen.

[1508] Through these processing steps, users can efficiently obtain the optimal alternative recipe tailored to their requirements and emotional state.

[1509] (Application Example 2)

[1510] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1511] While modern food recipe systems can accommodate specific user requirements such as allergies and dietary restrictions, systems that offer personalized recipe suggestions based on a user's emotional state still do not exist. In particular, meal suggestions that take into account emotions such as stress and joy are lacking, making it difficult to enhance users' psychological and emotional satisfaction. Furthermore, there are limitations to generating optimized alternative recipes, posing a challenge in quickly responding to diverse user needs.

[1512] The specific processing performed by the specific 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 collecting recipe information from a database of ingredient recipes, means for analyzing the collected recipe information and generating substitutes for each ingredient, means for simulating new recipe combinations using the generated substitutes, means for recognizing the user's emotions and making recipe suggestions based on them, and means for inputting emotions and requirements through a user interface and providing optimized recipes. This makes it possible to provide optimized alternative recipes that correspond to the user's specific requirements and emotional state.

[1513] A "food recipe database" is a digital structure for systematically storing and managing food recipe information.

[1514] "Recipe information" refers to a dataset containing detailed information such as ingredient lists, cooking instructions, and nutritional information.

[1515] A "food substitute" is an ingredient that can be used in place of a specific ingredient and has similar nutritional value or taste characteristics.

[1516] A "simulation" is the process of using data and algorithms to mimic real-world situations and predict outcomes under hypothetical conditions.

[1517] "Specific user requirements" refer to detailed conditions desired by individual users, such as allergy information, food preferences, and nutritional needs.

[1518] "Filtering" is the process of selecting data that meets specific criteria from a large amount of data.

[1519] An "optimized recipe" is a recipe that has been tailored to the user's specific requirements and emotional state to be the most suitable for them.

[1520] "Means of recognizing emotions" refers to technologies and software used to analyze and identify a user's emotional state.

[1521] A "user interface" is an interactive environment for input and output that allows a user to interact with a system.

[1522] "Means of collection" refers to the functions and methods for obtaining recipe information from databases or the internet.

[1523] "Means of analysis" refers to the process of analyzing collected data and extracting meaningful information.

[1524] "Means of generating substitutes" refer to methods or algorithms for suggesting ingredients that can be used as substitutes for specific ingredients.

[1525] "Means of presentation" refers to methods and technologies for displaying user-optimized recipe information in an easy-to-understand format.

[1526] This invention is implemented as a system that provides food delivery services that respond to the specific requirements and emotional states of users. Specific embodiments of this system are described below.

[1527] System Configuration

[1528] This system includes the following main components.

[1529] 1. Data Acquisition Module

[1530] 2. Data Analysis Module

[1531] 3. Alternative Recipe Generation Module

[1532] 4. Emotion Recognition Engine

[1533] 5. User Interface Module

[1534] Data Acquisition Module

[1535] The server collects recipe information from online recipe and ingredient databases. This includes ingredient lists, cooking instructions, and nutritional information for each recipe. The collected data is stored in JSON format or in relational databases.

[1536] Data Analysis Module

[1537] The server analyzes the collected data using natural language processing (NLP). Specifically, it follows these steps:

[1538] The recipe information is divided, and each ingredient is tagged as a separate item.

[1539] Refer to a nutrition database and calculate the nutritional information for each ingredient.

[1540] The analysis results extract detailed information such as the type of material, nutritional value, and allergen information.

[1541] Alternative recipe generation module

[1542] The server uses AI models (e.g., machine learning models) to generate substitutes for each ingredient. It suggests ingredients with similar nutritional value and taste characteristics and simulates new recipes using them. This generates alternative recipes that are best suited to the user's specific requirements.

[1543] Emotion recognition engine

[1544] The emotion recognition engine recognizes the user's emotions using text input, voice, and facial recognition technology. The analyzed emotion information is then reflected in recipe suggestions. For example, if the user is feeling stressed, the engine will suggest recipes using ingredients that have a relaxing effect.

[1545] User Interface Module

[1546] The user enters specific requirements (e.g., allergy information, preference for certain ingredients) through the user interface. This input data is then sent to the server via the terminal.

[1547] For example, if a user enters "I have an egg allergy, but I want pancakes that don't use eggs," and the emotion recognition engine detects stress, the following prompt message will be generated.

[1548] Generate a recipe that meets the following requirements: Without eggs suitable for someone feeling stressed.

[1549] Sending this prompt to the server's AI model generates an optimized pancake recipe that includes vanilla extract, which has stress-reducing effects.

[1550] Examples

[1551] For example, if a user enters a request stating, "I have a dairy allergy, but I want to eat pasta with cream," the emotion recognition engine will recognize the user's emotional state and suggest a dairy-free alternative (e.g., soy cream). Furthermore, a recipe including ingredients that can improve the user's mood will be generated, tailored to their emotional state.

[1552] This allows users to quickly find the perfect meal tailored to their emotional state and specific requirements. The system can improve user satisfaction and provide a personalized food delivery service.

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

[1554] Step 1:

[1555] The server collects recipe information from recipe and ingredient databases on the internet. It uses HTTP requests to retrieve data from APIs and saves the retrieved data in JSON format. The input is the API URL, and the output is recipe data in JSON format.

[1556] Step 2:

[1557] The server analyzes the collected recipe data using a natural language processing (NLP) library. This process divides the recipe information and tags each ingredient as an independent item. It also refers to a nutrition database and calculates the nutritional information for each ingredient. The input is recipe data in JSON format, and the output is the analyzed recipe data and nutritional information.

[1558] Step 3:

[1559] The server receives specific requirements and sentiment information entered by the user. It collects requirements entered by the user through the user interface and sentiment information recognized by the sentiment recognition engine. The input consists of the user's requirements and sentiment information, while the output consists of the received requirements and sentiment information.

[1560] Step 4:

[1561] The emotion recognition engine analyzes user input text and voice to recognize the user's emotional state. Specifically, it uses speech recognition software and facial recognition technology to evaluate the user's emotions. The input is the user's text and voice data, and the output is the recognized emotion information.

[1562] Step 5:

[1563] The server uses an AI model to generate alternative recipes based on analyzed recipe data, user requirements, and sentiment information. This process generates the optimal recipe by combining alternative ingredients that meet the user's requirements (e.g., allergy information). The input is the analyzed recipe data, user requirements, and sentiment information, and the output is the generated alternative recipe.

[1564] Step 6:

[1565] The server filters and optimizes the generated alternative recipes. During this process, it selects the optimal recipe, taking into account factors such as the nutritional value of the ingredients used and the user's emotional state. The input is the generated alternative recipe, and the output is the optimized, best-in-class recipe.

[1566] Step 7:

[1567] The user interface presents optimized recipe information to the user. A text generation module is used to generate detailed recipe descriptions for easy viewing. The input is optimized recipe information, and the output is a text-based recipe description for display to the user.

[1568] As a concrete example of its operation, if a user enters a request such as "I have an egg allergy, but I would like pancakes that do not contain eggs," and the emotion recognition engine detects stress, the following prompt message will be generated.

[1569] Generate a recipe that meets the following requirements: Without eggs suitable for someone feeling stressed.

[1570] By sending this prompt to the AI ​​model, an optimized pancake recipe containing vanilla extract, known for its stress-reducing effects, is generated. Finally, the user is shown through the user interface the message, "This recipe uses banana puree instead of eggs and also includes relaxing vanilla extract."

[1571] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the controlled object 443 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

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

[1573] 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 this disclosure is not limited thereto, and the specific processing may also be performed by the robot 414.

[1574] Furthermore, the emotion identification model 59, acting as an emotion engine, may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to a specific mapping, which is an emotion map (see Figure 9). Similarly, the emotion identification model 59 may also determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1575] Figure 9 shows an emotion map 400 in which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. The closer to the center of the concentric circles, the more primitive the emotions are located. Further out of the concentric circles, emotions representing states and actions arising from mental states are located. Emotion is a concept that includes feelings and mental states. On the left side of the concentric circles, emotions that are generally generated from reactions occurring in the brain are located. On the right side of the concentric circles, emotions that are generally induced by situational judgment are located. Above and below the concentric circles, emotions that are generally generated from reactions occurring in the brain and induced by situational judgment are located. In addition, the emotion of "pleasure" is located on the upper side of the concentric circles, and the emotion of "displeasure" is located on the lower side. Thus, in the emotion map 400, multiple emotions are mapped based on the structure in which emotions arise, and emotions that are likely to occur simultaneously are mapped close together.

[1576] These emotions are distributed at the 3 o'clock position on the Emotion Map 400, and usually fluctuate between feelings of security and anxiety. In the right half of the Emotion Map 400, situational awareness takes precedence over internal feelings, resulting in a calm impression.

[1577] The inside of the Emotion Map 400 represents inner thoughts, while the outside represents actions. Therefore, the further you go from the outside of the Emotion Map 400, the more visible (expressed in actions) your emotions become.

[1578] Here, human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. Similarly, in robots, cars, motorcycles, etc., emotions can be created based on various balances, such as posture and battery level. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. The emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on a system for analyzing brain physiological signals of speech emotion recognition and emotion, Tokushima University, doctoral dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map contains emotions belonging to a region called "response," where sensation is dominant. The right half of the emotion map contains emotions belonging to a region called "situation," where situational awareness is dominant.

[1579] The emotion map defines two emotions that promote learning. One is the emotion around the middle of the negative "repentance" and "reflection" on the situation side. In other words, it is when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is the emotion around the positive "desire" on the reaction side. In other words, it is when the robot has positive feelings such as "I want more" or "I want to know more."

[1580] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​representing each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple training data sets, which are combinations of user input and emotion values ​​representing each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions located close together have similar values, as shown in the emotion map 900 in Figure 10. Figure 10 shows an example where multiple emotions such as "reassured," "calm," and "confident" have similar emotion values.

[1581] The above description primarily focuses on the functions of the data processing device 12 in relation to this disclosure. However, the system related to this disclosure is not necessarily implemented on a server. The system related to this disclosure may be implemented as a general information processing system. This disclosure may be implemented, for example, as a software program that runs on a personal computer or as an application that runs on a smartphone. The method related to this disclosure may be provided to users in SaaS (Software as a Service) format.

[1582] In the above embodiment, an example was given in which a specific process is performed by a single computer 22. However, the technology of this disclosure is not limited thereto, and a distributed processing of the specific process may be performed by multiple computers, including computer 22. For example, a data generation model 58 may be provided in an external device of the data processing device 12, and the external device may generate data according to the input data.

[1583] In the above embodiment, an example was given in which the specific processing program 56 is stored in the storage 32, but the technology of this disclosure is not limited thereto. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-temporary storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-temporary storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes specific processing according to the specific processing program 56.

[1584] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1585] Furthermore, it is not necessary to store the entirety of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store the entirety of the specific processing program 56 in the storage 32; it is acceptable to store only a portion of the specific processing program 56.

[1586] The following types of processors can be used as hardware resources to perform specific processing. Examples of processors include a CPU, a general-purpose processor that functions as a hardware resource to perform specific processing by executing software, i.e., a program. Other examples of processors include dedicated electrical circuits, such as FPGAs (Field-Programmable Gate Arrays), PLDs (Programmable Logic Devices), or ASICs (Application Specific Integrated Circuits), which have circuit configurations specifically designed to perform specific processing. All of these processors have built-in or connected memory, and all of them perform specific processing by using memory.

[1587] The hardware resource that performs a specific process may consist of one of these various processors, or it may consist of a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Alternatively, the hardware resource that performs a specific process may consist of a single processor.

[1588] Examples of configurations using a single processor include, firstly, a configuration in which one or more CPUs and software are combined to form a single processor, and this processor functions as a hardware resource that performs a specific process. Secondly, there is a configuration using a processor that realizes the functions of the entire system, including multiple hardware resources that perform a specific process, on a single IC chip, as exemplified by SoCs (System-on-a-chip). In this way, a specific process is realized using one or more of the above types of processors as hardware resources.

[1589] Furthermore, the hardware structure of these various processors can more specifically utilize electrical circuits that combine circuit elements such as semiconductor devices. Also, the specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps can be deleted, new steps added, or the processing order rearranged, as long as it does not deviate from the main purpose.

[1590] The descriptions and illustrations presented above are detailed explanations of the technical aspects of this disclosure and are merely examples of the technical aspects. For example, the above descriptions of the structure, function, operation, and effect are examples of the structure, function, operation, and effect of the technical aspects of this disclosure. Therefore, it goes without saying that you may delete unnecessary parts, add new elements, or replace elements in the descriptions and illustrations presented above, as long as you do not deviate from the essence of the technical aspects of this disclosure. Furthermore, in order to avoid confusion and facilitate understanding of the technical aspects of this disclosure, explanations of common technical knowledge and the like that do not require special explanation to enable the implementation of the technical aspects of this disclosure have been omitted from the descriptions and illustrations presented above.

[1591] All documents, patent applications, and technical standards described herein are incorporated by reference to the same extent as if each individual document, patent application, and technical standard were specifically and individually noted to be incorporated by reference.

[1592] The following is further disclosed regarding the embodiments described above.

[1593] (Claim 1)

[1594] A means of collecting recipe information from a database of ingredient recipes,

[1595] A means of analyzing collected recipe information and generating substitutes for each ingredient,

[1596] A means of simulating new recipe combinations using the generated substitutes,

[1597] A system that includes means for receiving specific requirements from users and presenting filtered and optimized recipes.

[1598] (Claim 2)

[1599] The system according to claim 1, which divides and tags recipe information collected using natural language processing.

[1600] (Claim 3)

[1601] The system according to claim 1, which refers to a nutrition database and calculates nutritional information for each food ingredient.

[1602] (Claim 4)

[1603] The system according to claim 1, comprising a text generation means for describing the generated alternative recipe in natural language.

[1604] (Claim 5)

[1605] The system according to claim 1, comprising means for analyzing user input and extracting specific requirements.

[1606] "Example 1"

[1607] (Claim 1)

[1608] A means of collecting recipe information from multiple websites that provide recipe information via a communication network,

[1609] A method for analyzing recipe information collected using natural language processing technology and tagging each ingredient as an independent item,

[1610] A means of calculating the nutritional information of each food item by referring to a nutrition database,

[1611] A method for generating substitutes for each ingredient using machine learning models,

[1612] A means of simulating a new recipe using the generated substitutes,

[1613] A means for receiving specific requirements via a user terminal and presenting filtered and optimized recipes,

[1614] A system that includes...

[1615] (Claim 2)

[1616] The system according to claim 1, which divides and tags recipe information collected using natural language processing.

[1617] (Claim 3)

[1618] The system according to claim 1, which refers to a nutrition database and calculates nutritional information for each food ingredient.

[1619] "Application Example 1"

[1620] (Claim 1)

[1621] A means of collecting recipe information from a database of ingredient recipes,

[1622] A means of analyzing collected recipe information and generating substitutes for each ingredient,

[1623] A means of simulating new recipe combinations using the generated substitutes,

[1624] A means of receiving specific requirements from users and presenting filtered and optimized recipes,

[1625] A means of collecting and storing users' allergy information and food preferences,

[1626] A means to enable ordering of dishes based on alternative recipes, using collected user information.

[1627] A system that includes this.

[1628] (Claim 2)

[1629] The system according to claim 1, which divides and tags recipe information collected using natural language processing.

[1630] (Claim 3)

[1631] The system according to claim 1, which refers to a nutrition database and calculates nutritional information for each food ingredient.

[1632] "Example 2 of combining an emotion engine"

[1633] (Claim 1)

[1634] A means of collecting recipe information from a database of ingredient recipes,

[1635] A method for analyzing collected recipe information using natural language processing and generating substitutes for each ingredient,

[1636] A method for simulating new recipe combinations using generated substitutes with a machine learning model,

[1637] A system that includes means for receiving specific requirements and emotional states from a user, analyzing the emotional information using an emotion analysis engine, and presenting filtered and optimized recipes.

[1638] (Claim 2)

[1639] The system according to claim 1, which divides and tags collected recipe information using natural language processing.

[1640] (Claim 3)

[1641] The system according to claim 1, which refers to a nutrition database and calculates nutritional information for each food ingredient.

[1642] "Application example 2 when combining with an emotional engine"

[1643] (Claim 1)

[1644] A means of collecting recipe information from a database of ingredient recipes,

[1645] A means of analyzing collected recipe information and generating substitutes for each ingredient,

[1646] A means of simulating new recipe combinations using the generated substitutes,

[1647] A means of receiving specific requirements from users and presenting filtered and optimized recipes,

[1648] A means of recognizing user emotions and providing recipe suggestions based on them,

[1649] A means of inputting emotions and requirements through a user interface and providing optimized recipes.

[1650] Includes system.

[1651] (Claim 2)

[1652] The system according to claim 1, which divides and tags recipe information collected using natural language processing.

[1653] (Claim 3)

[1654] The system according to claim 1, which refers to a nutrition database and calculates nutritional information for each food ingredient. [Explanation of symbols]

[1655] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Devices 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robots< / url:> < / url:> < / url:> < / url:>

Claims

1. A means of collecting recipe information from a database of ingredient recipes, A means of analyzing collected recipe information and generating substitutes for each ingredient, A means of simulating new recipe combinations using the generated substitutes, A system that includes means for receiving specific requirements from users and presenting filtered and optimized recipes.

2. The system according to claim 1, which divides and tags recipe information collected using natural language processing.

3. The system according to claim 1, which calculates nutritional information for each food ingredient by referring to a nutrition database.

4. The system according to claim 1, comprising a text generation means for describing the generated alternative recipe in natural language.

5. The system according to claim 1, comprising means for analyzing user input and extracting specific requirements.

Images