System

Abstract

A system is provided.SOLUTION: The system includes a means for inputting food material information by a user, a means for generating a proposal menu based on the food material information received by a server, a means for displaying the generated proposal menu to the user, and a means for updating the food material information based on the selection of the user.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] The rise in living costs due to rising prices is a serious problem for many households. The rise in food costs is particularly notable, and cooking at home is recommended as a way to reduce this. However, when cooking at home, there are many cases where ingredients are not used up and are thrown away, which increases the burden on the household budget. It is also difficult to determine what kind of menu is optimal. To solve these issues, a system that promotes efficient food use is needed. [Means for solving the problem]

[0005] The present invention is a system that allows a user to input ingredient information and generates and displays optimal menu suggestions based on that information. The system includes the following means:

[0006] A means for a user to input ingredient information;

[0007] A means for generating a menu suggestion based on the ingredient information received by the server;

[0008] means for displaying the generated suggestion menu to the user;

[0009] A means for updating ingredient information based on user selections.

[0010] Furthermore, it also includes a means for using an external API to generate suggested menus and collecting ingredient information entered by the user in dictionary format. In this way, it provides a system that reduces food waste and helps with efficient home cooking.

[0011] "User" refers to the entity that uses the system to input ingredient information and check and select the suggested menu.

[0012] "Ingredient information" is data regarding the type and amount of ingredients that the user inputs into the system.

[0013] The "means for inputting" is an interface or function for inputting ingredient information held by the user into the system.

[0014] A "server" is a computer system that receives and processes ingredient information sent by a user.

[0015] The "means for generating suggested menus" is an algorithm or software that creates optimal recipes and meal menus based on the received ingredient information.

[0016] An "external API" is an external application programming interface that the server uses to generate the suggestion menu.

[0017] The "display means" is an interface or function that visually presents the generated proposal menu to the user.

[0018] "User selection" refers to the act of the user selecting a desired menu from the proposed menus.

[0019] The "means for updating ingredient information" is a function for correcting and re-saving the amount of ingredients consumed based on the user's menu selection.

[0020] The "dictionary format" is a data structure that organizes and stores ingredient information as key-value pairs. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0029] [First embodiment]

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

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

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

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

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

[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 of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

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

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

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

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

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

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

[0042] As an embodiment of the present invention, a specific implementation method of a system in which a user inputs ingredient information held by the user and generates and displays the most suitable suggested menu based on that information will be described.

[0043] User input of ingredient information

[0044] First, the user inputs the ingredients they have on hand using the device. The device collects the types and quantities of the ingredients and organizes them into a dictionary. For example, if the user inputs "onions, 200g" and "carrots, 100g", the device organizes this information as follows:

[0045] python

[0046] {

[0047] 'Onion': '200g',

[0048] 'Carrots': '100g'

[0049] }

[0050] Server-generated menu suggestions

[0051] Next, the device sends the collected ingredient information to the server. The server generates a suggested menu based on the received ingredient information. The server uses an external API to create a recipe from the ingredient information. At this time, the server sets the ingredient information as an API prompt and generates the optimal menu based on the API response.

[0052] Specifically, you can send a prompt like this to the API:

[0053] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0054] Let's say the API returns a recipe for "onion and carrot soup."

[0055] Display of suggestion menu by device

[0056] The server generates a proposed menu and sends it to the terminal. The terminal displays the received proposed menu to the user. The user can check the proposed menu on the terminal.

[0057] User selects menu and updates ingredient information

[0058] The user selects the desired menu from the displayed suggested menu. For example, "onion and carrot soup" is selected. The device sends this selection information to the server. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[0059] Specifically, we update the ingredient information based on the selected menu, assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0060] python

[0061] {

[0062] 'onion': '100g',

[0063] 'Carrots': '50g'

[0064] }

[0065] The updated ingredient information is stored on the server and used the next time a menu is proposed. In this way, a system is provided that can efficiently utilize the ingredient information stored by the user and reduce waste.

[0066] The above is a specific embodiment for carrying out the present invention.

[0067] The processing flow will be explained below.

[0068] Step 1:

[0069] The user inputs the information about ingredients they have on hand into the terminal. Specifically, the user inputs the information in the format of "ingredient name, quantity", and when all the information has been input, the user enters "end" to finish.

[0070] Step 2:

[0071] The terminal collects ingredient information entered by the user. The collected information is organized in dictionary format, with the key being the ingredient name and the value being the quantity.

[0072] Step 3:

[0073] The terminal sends the organized ingredient information to the server, which then sends the ingredient information from the terminal to the server via the network.

[0074] Step 4:

[0075] The server processes the ingredient information received from the terminal, and the received information is temporarily stored on the server.

[0076] Step 5:

[0077] The server generates a suggested menu based on the received ingredient information. To achieve this, the server calls an external recipe generation API and sets the ingredient information as a prompt.

[0078] Step 6:

[0079] The server receives a response from the API, which includes suggested menus and recipes.

[0080] Step 7:

[0081] The server sends the proposed menu to the terminal, and the generated proposed menu is sent to the terminal via the network.

[0082] Step 8:

[0083] The terminal receives the proposed menu and displays it to the user, who can then check the proposed menu on the terminal screen.

[0084] Step 9:

[0085] The user selects the desired menu from the proposed menu, and the selected menu is notified to the server by the terminal.

[0086] Step 10:

[0087] The server updates the ingredient information based on the user's selection, specifically by calculating and updating the ingredients and amounts used in the selected menu.

[0088] Step 11:

[0089] The server saves the updated ingredient information, which is then reused the next time a menu is generated.

[0090] The above is a detailed explanation of the processing steps in this system, and the specific operations at each step have been explained in an easy-to-understand manner.

[0091] Example 1

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

[0093] In today's world, reducing food waste and using it efficiently is an important issue. However, there are only a limited number of systems that allow users to manage information about ingredients on hand and suggest appropriate menus based on that information. Conventional methods often require users to manually manage ingredient information and spend time thinking up recipe ideas. Furthermore, there are few systems that automatically update ingredient information based on suggested menus, which can easily lead to food waste. There is a need to provide a system that solves these problems.

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

[0095] In this invention, the server includes means for a user to input ingredient information, means for the terminal to organize the input ingredient information into dictionary format, means for the terminal to send the organized ingredient information to the server, means for the server to generate a suggested menu by sending a prompt to an external API based on the ingredient information received, means for displaying the generated suggested menu to the user, means for updating the ingredient information based on the user's selection, and means for using the updated ingredient information to generate the next suggested menu. This allows users to efficiently manage their available ingredient information and easily obtain suggested menus that make the most of ingredients without waste.

[0096] "User" refers to an individual who uses this system to input and manage ingredient information and receive suggested menus.

[0097] "Terminal" refers to an electronic device that a user uses to input ingredient information and that displays suggested menus.

[0098] "Ingredient information" refers to data that indicates the types and amounts of ingredients that a user owns.

[0099] "Dictionary format" refers to a method of organizing data using key-value pairs, specifically a format in which the names of ingredients are the keys and the quantities are the values.

[0100] The term "server" refers to a computer processing device that receives ingredient information sent from a terminal, generates menu suggestions based on that information, and sends the results to the terminal.

[0101] "External API" refers to an external application programming interface that the Server utilizes to generate the suggestion menu.

[0102] "Prompt text" refers to the explanatory text used when making a specific request to an external API.

[0103] "Suggested menu" refers to suggestions for recipes and dishes that the user can cook based on the input ingredient information.

[0104] "Update" refers to the act of updating ingredient information to the latest version based on the user's selection.

[0105] "Next time" refers to a future operation or use that follows the current operation.

[0106] The embodiments of the present invention will be specifically described below.

[0107] First, the user inputs ingredient information using their own device. The device collects the input ingredient information and organizes it in dictionary format. For example, if the user inputs "200g of onions" and "100g of carrots," the device converts this information into dictionary format and creates data organized as follows:

[0108] python

[0109] {

[0110] 'Onion': '200g',

[0111] 'Carrots': '100g'

[0112] }

[0113] Next, the device sends the organized ingredient information to the server. This is generally done using an HTTP request. The server uses an external API to generate menu suggestions based on the received ingredient information. The server sets the ingredient information as a prompt and sends a request to the external API. For example, the following prompt is sent to the external API:

[0114] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0115] The external API receives this prompt, creates a menu of suggestions based on that information, and returns a response to the server, such as a recipe for "onion and carrot soup."

[0116] The server analyzes the returned recipe information, generates a suggested menu that is optimal for the user, and sends it to the terminal. The terminal displays the suggested menu received from the server to the user. The user can check the suggested menu on the terminal and select the desired menu.

[0117] Furthermore, when the user selects the desired menu item, the device sends the selection information to the server. The server then updates the ingredient information based on the selected menu item. For example, the ingredient information is updated assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0118] python

[0119] {

[0120] 'onion': '100g',

[0121] 'Carrots': '50g'

[0122] }

[0123] The updated ingredient information is stored on the server and will be used the next time a menu is proposed.

[0124] This system allows users to efficiently manage information about ingredients on hand and easily obtain suggested menus that utilize ingredients without waste, thereby reducing food waste and providing a system that makes users' lives more convenient.

[0125] The above is a specific embodiment for carrying out the present invention.

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

[0127] Step 1:

[0128] The user uses the terminal to input information about ingredients they have on hand. For example, the user enters "200g of onions" and "100g of carrots" into the terminal's input form. This input information is the data that will be used as the basis for the next processing step.

[0129] Step 2:

[0130] The terminal collects the entered ingredient information and organizes it in dictionary format. For example, "200g of onions" and "100g of carrots" are converted into dictionary format as key-value pairs. Specifically, the data obtained from the form is converted into dictionary format within the program.

[0131] Step 3:

[0132] The device sends the organized ingredient information to the server. An HTTP request is used for transmission, and the ingredient information is sent in JSON format. At this time, the input dictionary-format data is sent to the server, allowing it to be processed on the server side.

[0133] Step 4:

[0134] The server generates a suggested menu based on the received ingredient information. To do this, the server uses an external API. Specifically, the server converts the ingredient information into a prompt and sends a request to the external API. In response to this request, the API returns the corresponding recipe information.

[0135] Step 5:

[0136] When creating the prompt, the server converts the data into a format such as:

[0137] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0138] By sending this prompt to the API, the appropriate recipe will be returned as a response.

[0139] Step 6:

[0140] The external API generates a recipe based on the received prompt and returns it to the server. For example, a recipe such as "onion and carrot soup" is returned. This information is received and analyzed on the server side.

[0141] Step 7:

[0142] The server analyzes the returned recipe information and generates a menu of suggestions, which are formatted in a way that is meaningful to the user and ready to be sent to the user in the next processing step.

[0143] Step 8:

[0144] The server sends the generated suggested menu to the terminal, and the terminal displays the received suggested menu to the user, who can then check the suggested menu on the terminal.

[0145] Step 9:

[0146] The user selects the desired menu from the displayed menu of suggestions, for example, "onion and carrot soup." This selection information is the basis for the next processing step.

[0147] Step 10:

[0148] The terminal transmits the user's selection information to the server. The transmission of the selected menu information to the server starts the processing in the next step.

[0149] Step 11:

[0150] The server updates the ingredient information based on the selected menu. Specifically, it updates the ingredient information it holds, assuming that "100g of onions" and "50g of carrots" have been consumed based on the selected menu. After the update, the ingredient information is kept up to date.

[0151] Step 12:

[0152] The updated ingredient information is stored on the server and used the next time a menu is proposed. This ensures that the ingredient information held by the user is always up-to-date, reducing waste.

[0153] The above is the flow of specific processing steps of this system.

[0154] (Application example 1)

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

[0156] In modern food manufacturing factories, reducing material waste and optimizing production plans are serious challenges. It is particularly difficult to efficiently manage the large amounts of materials used within the factory and consistently provide optimal production plans. This can lead to overpurchasing and waste of materials, which can increase manufacturing costs and reduce production efficiency. To solve these issues, a system is needed that can accurately grasp material information within the factory and automatically generate and provide optimal production plans based on that information.

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

[0158] In this invention, the server includes a means for a user to input ingredient information, a means for generating a proposed plan based on the ingredient information received by the server, and a means for displaying the generated proposed plan to the user. This allows factory robots to collect ingredient information and transmit the data to the cloud server, enabling production planning. Furthermore, by providing a means for updating ingredient information based on user selections, it is possible to reduce ingredient waste and consistently provide efficient production plans.

[0159] "Ingredient information" is data regarding the type and amount of food entered by the user.

[0160] "Proposed plan" refers to the optimal menu and production plan generated based on the input ingredient information.

[0161] "User" refers to the person who uses the system to input ingredient information and check and select the proposed plan, or the entity that operates the system.

[0162] "Server" refers to a computing device that receives ingredient information and generates and provides proposed plans.

[0163] A "factory robot" refers to an automated mechanical device that collects material information within a factory.

[0164] A "cloud server" is a remote server connected via the Internet that processes and stores data.

[0165] "Data transmission" refers to the process by which factory robots send collected material information to a cloud server.

[0166] "Manufacturing planning" refers to determining the optimal manufacturing process and work plan based on collected material information.

[0167] "Update" refers to the process of updating ingredient information to the latest version based on the user's selection.

[0168] As an embodiment of the present invention, a system will be described that utilizes factory robots in a food manufacturing factory to efficiently perform operations from collecting ingredient information to proposing a manufacturing plan and updating food ingredient information.

[0169] First, the factory robot collects information about the ingredients used in the factory. Specifically, it obtains the type and quantity of ingredients from sensors installed on the ingredient shelves and organizes them as food types and their quantities. For example, if there is 500g of flour and 200g of sugar, this information is collected in dictionary format.

[0170] Next, the device sends the collected material information to the cloud server. Based on the received material information, the cloud server uses a generative AI model to propose an optimal manufacturing plan. To use the generative AI model, the cloud server calls an external API and sets the material information as a prompt. Specifically, it sends the following prompt:

[0171] "Please propose a recipe using the following ingredients: 500g flour, 200g sugar, 100g butter."

[0172] The cloud server then receives the optimal manufacturing plan returned by the API and sends it to the device. The user can then review the proposed manufacturing plans on their device and select the one they prefer. The selected plan is then sent back to the cloud server, which calculates the amount of material consumed based on the selected plan and updates the material information.

[0173] For example, if a user selects a production plan that uses 200g of flour and 100g of sugar, the cloud server recalculates the new ingredient information, updating the flour to 300g and sugar to 100g. This updated information is used for the next menu generation.

[0174] This system enables food manufacturing factories to significantly reduce material waste and constantly provide efficient and optimal production plans. The specific hardware used includes sensors installed on material shelves, factory robots, and smartphones or tablets as terminals, while the cloud server requires an internet connection. The software used includes Raspberry Pi or Arduino for collecting sensor data, and Amazon Web Services or Google® Cloud Platform for the cloud server.

[0175] This will enable consistent material management and optimal production plans across the entire system, which is expected to significantly improve production efficiency in food manufacturing factories.

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

[0177] Step 1:

[0178] Factory robots collect material information.

[0179] Input: Data from sensors installed on material shelves.

[0180] Data processing: The data obtained from the sensors is organized into material types and quantities and converted into dictionary format.

[0181] Output: Collected ingredient information (e.g. "500g flour, 200g sugar").

[0182] Step 2:

[0183] The terminal sends material information to the cloud server.

[0184] Input: Material information collected and organized by factory robots.

[0185] Data processing: Material information is converted into JSON format and sent to the cloud server.

[0186] Output: Material information sent to the cloud server.

[0187] Step 3:

[0188] Based on the material information received by the server, a generative AI model is used to generate a proposed plan.

[0189] Input: Material information received by the cloud server.

[0190] Data processing: Send material information as prompts to an external API and use a generative AI model to obtain the optimal manufacturing plan.

[0191] Output: The generated production plan (e.g. "Production plan using 200g flour and 100g sugar").

[0192] Step 4:

[0193] The server transmits the generated manufacturing plan to the terminal, which displays it to the user.

[0194] Input: Generated manufacturing plan.

[0195] Data processing: The generated manufacturing plan is formatted into a form that is easy for users to understand.

[0196] Output: Manufacturing plan that the user sees on the terminal.

[0197] Step 5:

[0198] The user selects the desired manufacturing plan.

[0199] Input: Manufacturing plan displayed on the terminal.

[0200] Data processing: The user selects the manufacturing plan they deem most optimal and sends the selected information to the cloud server.

[0201] Output: The selected manufacturing plan.

[0202] Step 6:

[0203] The server updates the material information based on the selected manufacturing plan.

[0204] Input: The manufacturing plan selected by the user.

[0205] Data processing: Updates current material information based on the material consumption amount listed in the selected manufacturing plan.

[0206] Output: Updated ingredient information (e.g. "300g flour, 100g sugar").

[0207] These are the processing steps of the system program that realizes this application example. This automates material management and optimization of manufacturing plans within the factory, enabling efficient operation.

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

[0209] As an embodiment of the present invention, a specific implementation method of a system that inputs ingredients information of a user combined with an emotion engine and generates and displays suggested menus based on that information will be described.

[0210] User input of ingredient information

[0211] First, the user uses the device to input information about ingredients they have on hand. The device collects the types and quantities of the ingredients and organizes them into a dictionary. For example, if the user inputs "onions, 200g" and "carrots, 100g," the device organizes this information as follows:

[0212] python

[0213] {

[0214] 'Onion': '200g',

[0215] 'Carrots': '100g'

[0216] }

[0217] Acquiring user emotion information

[0218] The device is equipped with an emotion engine that recognizes the user's emotions in real time from their facial expressions and voice. This emotional information is taken into consideration when suggesting menu items.

[0219] Server-generated menu suggestions

[0220] Next, the device sends the collected ingredient information and the user's emotional information to the server. The server generates a suggested menu based on the received ingredient information and emotional information. The server uses an external API to create a recipe from this information. At this time, the server sets the ingredient information and emotional information as API prompts.

[0221] For example, set the prompt as follows:

[0222] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[0223] Let's say the API responds with a recipe for "Comforting Onion and Carrot Soup."

[0224] Display of suggestion menu by device

[0225] The server generates a suggested menu and sends it to the terminal. The terminal displays the received suggested menu to the user. The user can check the suggested menu on the terminal screen.

[0226] User selects menu and updates ingredient information

[0227] The user selects the desired menu from the displayed suggested menu. For example, suppose "onion and carrot soup" is selected. The selected menu is notified to the server by the terminal. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[0228] Specifically, we update the ingredient information based on the selected menu, assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0229] python

[0230] {

[0231] 'onion': '100g',

[0232] 'Carrots': '50g'

[0233] }

[0234] Update user emotion information

[0235] Furthermore, the emotion information is also updated based on the menu selected by the user. For example, if a specific menu is determined to have the effect of refreshing the user's mood, the emotion engine will update the user's emotion as "refreshed."

[0236] The updated ingredient information and emotion information are stored on the server and used the next time a menu is proposed. In this way, the system efficiently utilizes the ingredient information stored by the user, reduces waste, and responds to changes in the user's emotions.

[0237] The above is a specific embodiment for carrying out the present invention.

[0238] The processing flow will be explained below.

[0239] Step 1:

[0240] The user inputs information about ingredients they have on hand into the terminal. The user inputs the information in the format of "ingredient name, quantity", and when they have finished inputting all the information, they input "end" to complete the input.

[0241] Step 2:

[0242] The terminal collects ingredient information entered by the user. The collected information is organized in dictionary format, with the key being the ingredient name and the value being the quantity.

[0243] Step 3:

[0244] The device uses an emotion engine to collect the user's emotional information, evaluating the user's emotions in real time through facial expressions and voice analysis, and collecting this emotional information as independent data.

[0245] Step 4:

[0246] The terminal transmits the organized ingredient information and collected emotion information to the server, which then transmits the ingredient information and emotion information to the server via a network.

[0247] Step 5:

[0248] The server processes the ingredient information and emotion information received from the device. The received information is temporarily stored on the server.

[0249] Step 6:

[0250] The server generates a suggested menu based on the ingredient information and emotion information. The server calls an external recipe generation API and sets the ingredient information and emotion information as a prompt. For example, the prompt could be set as follows: "Please suggest a recipe using the following ingredients that matches the current user's emotion: {'onion': '200g', 'carrot': '100g'} User emotion: 'Feeling tired'."

[0251] Step 7:

[0252] The server receives the response from the API and retrieves the suggested menu. For example, if the API returns a recipe for "Relaxing Onion and Carrot Soup," the server retrieves this menu information.

[0253] Step 8:

[0254] The server sends the acquired proposal menu to the terminal, and the generated proposal menu is sent to the terminal via the network.

[0255] Step 9:

[0256] The terminal receives the proposed menu and displays it to the user, who can then check the proposed menu on the terminal screen.

[0257] Step 10:

[0258] The user selects the desired menu from the displayed suggested menu. For example, the user selects "onion and carrot soup." The selected menu is notified to the server by the terminal.

[0259] Step 11:

[0260] The server updates the ingredient information based on the user's selection. It calculates the ingredients used in the selected menu and their amounts, and updates the ingredient information assuming that, for example, 100g of onions and 50g of carrots were consumed. In this case, the updated data will look like this:

[0261] python

[0262] {

[0263] 'onion': '100g',

[0264] 'Carrots': '50g'

[0265] }

[0266] Step 12:

[0267] The server saves the updated ingredient information, which is then reused the next time a menu is generated.

[0268] Step 13:

[0269] The emotion engine updates the emotion information based on the user's selection. For example, if a particular menu item is determined to have a refreshing effect on the user's mood, the emotion engine updates the user's emotion as "refreshed."

[0270] Step 14:

[0271] The server stores the updated emotion information, so that the next time a menu suggestion is generated, the user's latest emotion state can be taken into account.

[0272] The above are the specific steps for carrying out the present invention, and the specific operations at each step have been explained in detail.

[0273] Example 2

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

[0275] Conventional ingredient management and recipe suggestion systems mainly display suggested menus based on ingredient information entered by the user, but have the problem of not being able to take into account individual states such as the user's emotions. Furthermore, while it is expected that more personalized suggestions will be possible by utilizing the user's emotional information when generating suggested menus, there has been a lack of means to achieve this.

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

[0277] In this invention, the server includes a means for a user to input ingredient information, a means for the terminal to organize the input ingredient information into dictionary format, a means for the terminal to acquire user emotional information, a means for the server to receive the emotional information and ingredient information, a means for the server to generate a suggested menu based on the ingredient information and emotional information received, a means for the terminal to display the generated suggested menu to the user, and a means for updating the ingredient information and emotional information based on the user's selection. This makes it possible to provide a more personalized suggested menu that takes into account the user's emotional information, which is expected to improve user satisfaction.

[0278] A "user" is an entity that uses this system to input ingredient information and emotional information and use the suggested menu.

[0279] A "terminal" is a device that a user accesses to input ingredient information, acquire emotional information, and display suggested menus.

[0280] The "server" is a central processing unit that generates menu suggestions based on the ingredient information and emotion information sent from the terminal.

[0281] An "emotion engine" is software or hardware that analyzes emotions from a user's facial expressions and voice in real time and acquires appropriate emotional information.

[0282] "Ingredient information" is data relating to the types and amounts of ingredients that the user owns.

[0283] A "suggested menu" is a cooking recipe that the server generates based on ingredient information and emotion information and presents to the user.

[0284] "External API" means an external application programming interface that the server uses to generate the suggestion menu.

[0285] The "dictionary format" is a data format that organizes ingredient information as key-value pairs and manages them efficiently.

[0286] "Update" is an operation for keeping ingredient information and emotion information up to date according to user selection.

[0287] "Real-time" is a time frame that means data is acquired and processed immediately.

[0288] As an embodiment of the present invention, a specific implementation method of a system that inputs ingredients information of a user combined with an emotion engine and generates and displays suggested menus based on that information will be described.

[0289] User input of ingredient information

[0290] First, the user uses the terminal to input information about ingredients they have on hand. The terminal collects the types and quantities of the ingredients entered and organizes them in dictionary format. For example, if the user enters "onions, 200g" and "carrots, 100g," the terminal organizes this information. Dictionary format is a data format that organizes ingredient information as key-value pairs and manages them efficiently. The terminal is designed to make it easy for users to input information using a GUI (Graphical User Interface).

[0291] Acquiring user emotion information

[0292] Next, the device is equipped with an emotion engine that recognizes emotions in real time from the user's facial expressions and voice. This emotional information is taken into consideration when suggesting recipes. The emotion engine acquires data, for example, through a camera or microphone, and analyzes it in real time. Examples of software used include OpenCV and DeepFace.

[0293] Server-generated menu suggestions

[0294] The device sends the collected ingredient information and the user's emotional information to the server. The server generates a suggested menu based on the received information. The server uses an external API to generate a recipe from this information. At this time, the server sets the ingredient information and emotional information as the API prompt. The prompt text is set as follows:

[0295] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[0296] Thus, the API might respond with a recipe for "Comforting Onion and Carrot Soup."

[0297] Display of suggestion menu by device

[0298] The server sends the generated suggested menu to the terminal. The terminal displays the received suggested menu to the user. The user can check the suggested menu on the terminal screen. The screen displays the recipe name, ingredients, steps, etc., allowing the user to intuitively select a menu.

[0299] User selects menu and updates ingredient information

[0300] The user selects the desired menu from the displayed suggested menu. For example, suppose "onion and carrot soup" is selected. The selected menu is notified to the server by the terminal. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount. For example, the ingredient information is updated assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the ingredient information is updated according to the selected menu.

[0301] Update user emotion information

[0302] Furthermore, the emotion information is also updated based on the menu selected by the user. For example, if a specific menu is determined to have the effect of refreshing the user's mood, the emotion engine updates the user's emotion to "refreshed." This updated emotion information is used when generating the next suggested menu.

[0303] In this way, a system is provided that efficiently utilizes the food ingredient information held by the user, reduces waste, and also responds to changes in the user's emotions.

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

[0305] Step 1: User enters ingredient information

[0306] The user launches the device app and inputs information about ingredients they have on hand through text boxes and drop-down lists. For example, they might input information like "onions, 200g" or "carrots, 100g." The device receives this information and converts it into a dictionary format. The dictionary format manages pairs of ingredient names as keys and quantities as values. For example, it can be formatted as follows:

[0307] python

[0308] {

[0309] 'Onion': '200g',

[0310] 'Carrots': '100g'

[0311] }

[0312] Input: Ingredient information entered by the user

[0313] Output: Ingredient information organized in dictionary format

[0314] Step 2: Obtaining user emotion information

[0315] The device's built-in emotion engine analyzes the user's facial expressions and voice in real time through the camera and microphone, using software libraries such as OpenCV and DeepFace. The analyzed emotion data is then classified as "tired" or "confused," for example.

[0316] Input: User facial and voice data acquired from camera and microphone

[0317] Output: Parsed emotion information

[0318] Step 3: Server generates suggestion menu

[0319] The device sends the organized ingredient information and analyzed emotion information to the server. The server receives them and generates a prompt. This prompt is set as a request to the external API. For example, the prompt is generated as follows:

[0320] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[0321] The server sends this prompt to an external recipe API, which generates an appropriate recipe and returns it to the server.

[0322] Input: Ingredient information and emotional information sent from the device

[0323] Output: Suggestion menu returned from external API

[0324] Step 4: Display the suggestion menu by device

[0325] The server sends the suggested menu received from the external API to the device. The device receives this information and displays it to the user. The screen displays the recipe name, ingredients, steps, etc. For example, it displays a recipe for "Relaxing Onion and Carrot Soup."

[0326] Input: Suggestion menu sent from the server

[0327] Output: The suggestion menu displayed to the user

[0328] Step 5: User selects menu and updates ingredients

[0329] The user selects the desired menu from the suggested menu. Once the selection is made, the device notifies the server of the selection. The server updates the ingredient information based on the selected menu. For example, let's assume that "100g of onions" and "50g of carrots" are used. The updated ingredient information will be as follows:

[0330] python

[0331] {

[0332] 'onion': '100g',

[0333] 'Carrots': '50g'

[0334] }

[0335] Input: Menu information selected by the user

[0336] Output: Updated ingredient information

[0337] Step 6: Update user's emotion information

[0338] The emotion engine is then run again to evaluate the impact of the selected menu on the user's emotions. For example, if the selected menu is determined to be "refreshed," the new emotion information is notified to the server and updated. This ensures that the latest emotion information is taken into account when suggesting a menu next time.

[0339] Input: User menu choices and their impact

[0340] Output: Updated emotion information

[0341] These processing steps realize a system that provides personalized menu suggestions based on the user's ingredient information and emotional information.

[0342] (Application example 2)

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

[0344] Conventional menu suggestion generation systems are unable to take the user's emotions into account, making it impossible to suggest appropriate menus that reflect the user's mental state at any given time. Furthermore, managing the user's ingredient information is cumbersome, making it difficult to suggest efficient menus. There is a need for a system that can overcome these drawbacks and make efficient menu suggestions while taking the user's emotional information into account.

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

[0346] In this invention, the server includes a means for a user to input ingredient information, a means for generating a suggested menu based on the ingredient information and emotion information received by the server, a means for displaying the generated suggested menu to the user, a means for updating the ingredient information based on the user's selection, and a means for acquiring the user's emotion information using an emotion engine built into the terminal. This makes it possible to propose an optimal menu based on the user's emotion information and efficiently manage ingredient information.

[0347] "Ingredient information" is information that indicates the types and amounts of ingredients that the user has on hand.

[0348] A "suggested menu" refers to a recipe or menu of food that is generated by the server based on the ingredient information and emotion information entered by the user.

[0349] "Emotion information" is information about the user's mental state that the emotion engine obtains in real time from the user's facial expressions and voice.

[0350] An "emotion engine" is an engine that analyzes the user's facial expressions and voice to recognize and acquire their emotions in real time.

[0351] An "external API" is an external application programming interface for generating a suggestion menu based on a request from a server.

[0352] A "terminal" is a device (such as a smartphone or tablet) that allows a user to input ingredient information, acquire emotion information, and display suggested menus.

[0353] In this embodiment, a system is used in which a server, a terminal, and a user each play their respective roles. Here, we will explain in detail the process of inputting information about ingredients and emotions from the user, and generating and displaying the optimal menu suggestions based on that information.

[0354] First, the user uses a device (such as a smartphone or tablet) to input information about ingredients they have on hand. The device collects the types and quantities of the ingredients entered and organizes them in dictionary format. For example, if a user enters "tomatoes, 200g" and "chicken, 150g," the device organizes this information and sends it to the server. The server receives and analyzes this information.

[0355] Next, the device is equipped with an emotion engine that recognizes emotional information in real time from the user's facial expressions, voice, etc. This emotional information is also sent to the server and analyzed together with the ingredient information.

[0356] The server generates a suggested menu based on the received ingredient information and emotion information. The server uses an external API to generate the optimal recipe from this information. In this case, the server sets the ingredient information and emotion information as a prompt. Specifically, the server uses the following prompt text:

[0357] "Suggest a recipe using the following ingredients and matching the user's current emotion: {'tomato': '200g', 'chicken': '150g'} User emotion: 'stressed'"

[0358] Based on this prompt, the generative AI model responds with a suggested menu item (e.g., "Relaxed salad with tomatoes and chicken").

[0359] The generated suggested menu is sent from the server to the terminal, which displays it to the user. The user checks the suggested menu on the terminal screen and selects the desired menu. The selected menu is notified to the server by the terminal, and the server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[0360] For example, if a user selects "Relaxed Tomato and Chicken Salad" and the menu requires "100g of tomatoes and 50g of chicken," the server updates the ingredient information and stores "100g of tomatoes and 100g of chicken" as new data.

[0361] Furthermore, the emotion information is also updated based on the selected menu. If a particular menu is determined to have an effect of improving the user's mood, the emotion engine updates the user's emotion information as "refreshed."

[0362] In this way, it is possible to provide a system that efficiently utilizes the ingredient information held by the user, reduces waste, and also responds to changes in the user's emotions.

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

[0364] Step 1:

[0365] The user uses the terminal to input information about ingredients they have on hand. The type and amount of the ingredients entered become input data, and the terminal organizes this into a dictionary format. For example, inputs such as "tomato, 200g" and "chicken, 150g" are organized as "{'tomato': '200g', 'chicken': '150g'}". The organized data is then sent directly to the server.

[0366] Step 2:

[0367] The emotion engine built into the device analyzes the user's facial expressions and voice in real time to obtain the user's emotional information. For example, if the user is feeling stressed, the emotion information extracted will be "feeling stressed." The obtained emotion information is also sent to the server.

[0368] Step 3:

[0369] The server generates a suggested menu based on the received ingredient information and emotion information. Specifically, it sets the ingredient information and emotion information as a prompt and sends a request to an external API equipped with a generative AI model. The server receives the optimal recipe as a response from the external API. For example, the prompt text could be "Please suggest a recipe using the following ingredients that matches the user's current emotion: {'tomato': '200g', 'chicken': '150g'} User emotion: 'I'm feeling stressed'."

[0370] Step 4:

[0371] The server receives a menu suggestion generated from an external API (e.g., "Relaxed salad with tomatoes and chicken") and sends it to the device. The device displays the menu suggestion to the user.

[0372] Step 5:

[0373] The user checks the suggested menu displayed on the device and selects the desired menu item. For example, they select "Relaxed Tomato and Chicken Salad." The selected menu item is notified to the server from the device.

[0374] Step 6:

[0375] The server updates the ingredient information based on the ingredient consumption amounts corresponding to the selected menu. For example, if "100g of tomatoes and 50g of chicken" are consumed, the server updates the ingredient information to "100g of tomatoes and 100g of chicken." The updated information is saved on the server and will be used the next time a suggested menu is generated.

[0376] Step 7:

[0377] Furthermore, the emotional information is updated based on the impact of the selected menu on the user's emotions. For example, the emotional state is updated to "refreshed." The emotion engine recognizes this data and sends it to the server. The new emotional information is also saved on the server and used for the next suggestion.

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

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

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

[0381] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0394] As an embodiment of the present invention, a specific implementation method of a system in which a user inputs ingredient information held by the user and generates and displays the most suitable suggested menu based on that information will be described.

[0395] User input of ingredient information

[0396] First, the user inputs the ingredients they have on hand using the device. The device collects the types and quantities of the ingredients and organizes them into a dictionary. For example, if the user inputs "onions, 200g" and "carrots, 100g", the device organizes this information as follows:

[0397] python

[0398] {

[0399] 'Onion': '200g',

[0400] 'Carrots': '100g'

[0401] }

[0402] Server-generated menu suggestions

[0403] Next, the device sends the collected ingredient information to the server. The server generates a suggested menu based on the received ingredient information. The server uses an external API to create a recipe from the ingredient information. At this time, the server sets the ingredient information as an API prompt and generates the optimal menu based on the API response.

[0404] Specifically, you can send a prompt like this to the API:

[0405] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0406] Let's say the API returns a recipe for "onion and carrot soup."

[0407] Display of suggestion menu by device

[0408] The server generates a proposed menu and sends it to the terminal. The terminal displays the received proposed menu to the user. The user can check the proposed menu on the terminal.

[0409] User selects menu and updates ingredient information

[0410] The user selects the desired menu from the displayed suggested menu. For example, "onion and carrot soup" is selected. The device sends this selection information to the server. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[0411] Specifically, we update the ingredient information based on the selected menu, assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0412] python

[0413] {

[0414] 'onion': '100g',

[0415] 'Carrots': '50g'

[0416] }

[0417] The updated ingredient information is stored on the server and used the next time a menu is proposed. In this way, a system is provided that can efficiently utilize the ingredient information stored by the user and reduce waste.

[0418] The above is a specific embodiment for carrying out the present invention.

[0419] The processing flow will be explained below.

[0420] Step 1:

[0421] The user inputs the information about ingredients they have on hand into the terminal. Specifically, the user inputs the information in the format of "ingredient name, quantity", and when all the information has been input, the user enters "end" to finish.

[0422] Step 2:

[0423] The terminal collects ingredient information entered by the user. The collected information is organized in dictionary format, with the key being the ingredient name and the value being the quantity.

[0424] Step 3:

[0425] The terminal sends the organized ingredient information to the server, which then sends the ingredient information from the terminal to the server via the network.

[0426] Step 4:

[0427] The server processes the ingredient information received from the terminal, and the received information is temporarily stored on the server.

[0428] Step 5:

[0429] The server generates a suggested menu based on the received ingredient information. To achieve this, the server calls an external recipe generation API and sets the ingredient information as a prompt.

[0430] Step 6:

[0431] The server receives a response from the API, which includes suggested menus and recipes.

[0432] Step 7:

[0433] The server sends the proposed menu to the terminal, and the generated proposed menu is sent to the terminal via the network.

[0434] Step 8:

[0435] The terminal receives the proposed menu and displays it to the user, who can then check the proposed menu on the terminal screen.

[0436] Step 9:

[0437] The user selects the desired menu from the proposed menu, and the selected menu is notified to the server by the terminal.

[0438] Step 10:

[0439] The server updates the ingredient information based on the user's selection, specifically by calculating and updating the ingredients and amounts used in the selected menu.

[0440] Step 11:

[0441] The server saves the updated ingredient information, which is then reused the next time a menu is generated.

[0442] The above is a detailed explanation of the processing steps in this system, and the specific operations at each step have been explained in an easy-to-understand manner.

[0443] Example 1

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

[0445] In today's world, reducing food waste and using it efficiently is an important issue. However, there are only a limited number of systems that allow users to manage information about ingredients on hand and suggest appropriate menus based on that information. Conventional methods often require users to manually manage ingredient information and spend time thinking up recipe ideas. Furthermore, there are few systems that automatically update ingredient information based on suggested menus, which can easily lead to food waste. There is a need to provide a system that solves these problems.

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

[0447] In this invention, the server includes means for a user to input ingredient information, means for the terminal to organize the input ingredient information into dictionary format, means for the terminal to send the organized ingredient information to the server, means for the server to generate a suggested menu by sending a prompt to an external API based on the ingredient information received, means for displaying the generated suggested menu to the user, means for updating the ingredient information based on the user's selection, and means for using the updated ingredient information to generate the next suggested menu. This allows users to efficiently manage their available ingredient information and easily obtain suggested menus that make the most of ingredients without waste.

[0448] "User" refers to an individual who uses this system to input and manage ingredient information and receive suggested menus.

[0449] "Terminal" refers to an electronic device that a user uses to input ingredient information and that displays suggested menus.

[0450] "Ingredient information" refers to data that indicates the types and amounts of ingredients that a user owns.

[0451] "Dictionary format" refers to a method of organizing data using key-value pairs, specifically a format in which the names of ingredients are the keys and the quantities are the values.

[0452] The term "server" refers to a computer processing device that receives ingredient information sent from a terminal, generates menu suggestions based on that information, and sends the results to the terminal.

[0453] "External API" refers to an external application programming interface that the Server utilizes to generate the suggestion menu.

[0454] "Prompt text" refers to the explanatory text used when making a specific request to an external API.

[0455] "Suggested menu" refers to suggestions for recipes and dishes that the user can cook based on the input ingredient information.

[0456] "Update" refers to the act of updating ingredient information to the latest version based on the user's selection.

[0457] "Next time" refers to a future operation or use that follows the current operation.

[0458] The embodiments of the present invention will be specifically described below.

[0459] First, the user inputs ingredient information using their own device. The device collects the input ingredient information and organizes it in dictionary format. For example, if the user inputs "200g of onions" and "100g of carrots," the device converts this information into dictionary format and creates data organized as follows:

[0460] python

[0461] {

[0462] 'Onion': '200g',

[0463] 'Carrots': '100g'

[0464] }

[0465] Next, the device sends the organized ingredient information to the server. This is generally done using an HTTP request. The server uses an external API to generate menu suggestions based on the received ingredient information. The server sets the ingredient information as a prompt and sends a request to the external API. For example, the following prompt is sent to the external API:

[0466] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0467] The external API receives this prompt, creates a menu of suggestions based on that information, and returns a response to the server, such as a recipe for "onion and carrot soup."

[0468] The server analyzes the returned recipe information, generates a suggested menu that is optimal for the user, and sends it to the terminal. The terminal displays the suggested menu received from the server to the user. The user can check the suggested menu on the terminal and select the desired menu.

[0469] Furthermore, when the user selects the desired menu item, the device sends the selection information to the server. The server then updates the ingredient information based on the selected menu item. For example, the ingredient information is updated assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0470] python

[0471] {

[0472] 'onion': '100g',

[0473] 'Carrots': '50g'

[0474] }

[0475] The updated ingredient information is stored on the server and will be used the next time a menu is proposed.

[0476] This system allows users to efficiently manage information about ingredients on hand and easily obtain suggested menus that utilize ingredients without waste, thereby reducing food waste and providing a system that makes users' lives more convenient.

[0477] The above is a specific embodiment for carrying out the present invention.

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

[0479] Step 1:

[0480] The user uses the terminal to input information about ingredients they have on hand. For example, the user enters "200g of onions" and "100g of carrots" into the terminal's input form. This input information is the data that will be used as the basis for the next processing step.

[0481] Step 2:

[0482] The terminal collects the entered ingredient information and organizes it in dictionary format. For example, "200g of onions" and "100g of carrots" are converted into dictionary format as key-value pairs. Specifically, the data obtained from the form is converted into dictionary format within the program.

[0483] Step 3:

[0484] The device sends the organized ingredient information to the server. An HTTP request is used for transmission, and the ingredient information is sent in JSON format. At this time, the input dictionary-format data is sent to the server, allowing it to be processed on the server side.

[0485] Step 4:

[0486] The server generates a suggested menu based on the received ingredient information. To do this, the server uses an external API. Specifically, the server converts the ingredient information into a prompt and sends a request to the external API. In response to this request, the API returns the corresponding recipe information.

[0487] Step 5:

[0488] When creating the prompt, the server converts the data into a format such as:

[0489] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0490] By sending this prompt to the API, the appropriate recipe will be returned as a response.

[0491] Step 6:

[0492] The external API generates a recipe based on the received prompt and returns it to the server. For example, a recipe such as "onion and carrot soup" is returned. This information is received and analyzed on the server side.

[0493] Step 7:

[0494] The server analyzes the returned recipe information and generates a menu of suggestions, which are formatted in a way that is meaningful to the user and ready to be sent to the user in the next processing step.

[0495] Step 8:

[0496] The server sends the generated suggested menu to the terminal, and the terminal displays the received suggested menu to the user, who can then check the suggested menu on the terminal.

[0497] Step 9:

[0498] The user selects the desired menu from the displayed menu of suggestions, for example, "onion and carrot soup." This selection information is the basis for the next processing step.

[0499] Step 10:

[0500] The terminal transmits the user's selection information to the server. The transmission of the selected menu information to the server starts the processing in the next step.

[0501] Step 11:

[0502] The server updates the ingredient information based on the selected menu. Specifically, it updates the ingredient information it holds, assuming that "100g of onions" and "50g of carrots" have been consumed based on the selected menu. After the update, the ingredient information is kept up to date.

[0503] Step 12:

[0504] The updated ingredient information is stored on the server and used the next time a menu is proposed. This ensures that the ingredient information held by the user is always up-to-date, reducing waste.

[0505] The above is the flow of specific processing steps of this system.

[0506] (Application example 1)

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

[0508] In modern food manufacturing factories, reducing material waste and optimizing production plans are serious challenges. It is particularly difficult to efficiently manage the large amounts of materials used within the factory and consistently provide optimal production plans. This can lead to overpurchasing and waste of materials, which can increase manufacturing costs and reduce production efficiency. To solve these issues, a system is needed that can accurately grasp material information within the factory and automatically generate and provide optimal production plans based on that information.

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

[0510] In this invention, the server includes a means for a user to input ingredient information, a means for generating a proposed plan based on the ingredient information received by the server, and a means for displaying the generated proposed plan to the user. This allows factory robots to collect ingredient information and transmit the data to the cloud server, enabling production planning. Furthermore, by providing a means for updating ingredient information based on user selections, it is possible to reduce ingredient waste and consistently provide efficient production plans.

[0511] "Ingredient information" is data regarding the type and amount of food entered by the user.

[0512] "Proposed plan" refers to the optimal menu and production plan generated based on the input ingredient information.

[0513] "User" refers to the person who uses the system to input ingredient information and check and select the proposed plan, or the entity that operates the system.

[0514] "Server" refers to a computing device that receives ingredient information and generates and provides proposed plans.

[0515] A "factory robot" refers to an automated mechanical device that collects material information within a factory.

[0516] A "cloud server" is a remote server connected via the Internet that processes and stores data.

[0517] "Data transmission" refers to the process by which factory robots send collected material information to a cloud server.

[0518] "Manufacturing planning" refers to determining the optimal manufacturing process and work plan based on collected material information.

[0519] "Update" refers to the process of updating ingredient information to the latest version based on the user's selection.

[0520] As an embodiment of the present invention, a system will be described that utilizes factory robots in a food manufacturing factory to efficiently perform operations from collecting ingredient information to proposing a manufacturing plan and updating food ingredient information.

[0521] First, the factory robot collects information about the ingredients used in the factory. Specifically, it obtains the type and quantity of ingredients from sensors installed on the ingredient shelves and organizes them as food types and their quantities. For example, if there is 500g of flour and 200g of sugar, this information is collected in dictionary format.

[0522] Next, the device sends the collected material information to the cloud server. Based on the received material information, the cloud server uses a generative AI model to propose an optimal manufacturing plan. To use the generative AI model, the cloud server calls an external API and sets the material information as a prompt. Specifically, it sends the following prompt:

[0523] "Please propose a recipe using the following ingredients: 500g flour, 200g sugar, 100g butter."

[0524] The cloud server then receives the optimal manufacturing plan returned by the API and sends it to the device. The user can then review the proposed manufacturing plans on their device and select the one they prefer. The selected plan is then sent back to the cloud server, which calculates the amount of material consumed based on the selected plan and updates the material information.

[0525] For example, if a user selects a production plan that uses 200g of flour and 100g of sugar, the cloud server recalculates the new ingredient information, updating the flour to 300g and sugar to 100g. This updated information is used for the next menu generation.

[0526] This system enables food manufacturing factories to significantly reduce material waste and consistently provide efficient and optimal production plans. The specific hardware used includes sensors installed on material shelves, factory robots, and smartphones or tablets as terminals, while the cloud server requires an internet connection. The software used is Raspberry Pi or Arduino for sensor data collection, and Amazon Web Services or Google Cloud Platform for the cloud server.

[0527] This will enable consistent material management and optimal production plans across the entire system, which is expected to significantly improve production efficiency in food manufacturing factories.

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

[0529] Step 1:

[0530] Factory robots collect material information.

[0531] Input: Data from sensors installed on material shelves.

[0532] Data processing: The data obtained from the sensors is organized into material types and quantities and converted into dictionary format.

[0533] Output: Collected ingredient information (e.g. "500g flour, 200g sugar").

[0534] Step 2:

[0535] The terminal sends material information to the cloud server.

[0536] Input: Material information collected and organized by factory robots.

[0537] Data processing: Material information is converted into JSON format and sent to the cloud server.

[0538] Output: Material information sent to the cloud server.

[0539] Step 3:

[0540] Based on the material information received by the server, a generative AI model is used to generate a proposed plan.

[0541] Input: Material information received by the cloud server.

[0542] Data processing: Send material information as prompts to an external API and use a generative AI model to obtain the optimal manufacturing plan.

[0543] Output: The generated production plan (e.g. "Production plan using 200g flour and 100g sugar").

[0544] Step 4:

[0545] The server transmits the generated manufacturing plan to the terminal, which displays it to the user.

[0546] Input: Generated manufacturing plan.

[0547] Data processing: The generated manufacturing plan is formatted into a form that is easy for users to understand.

[0548] Output: Manufacturing plan that the user sees on the terminal.

[0549] Step 5:

[0550] The user selects the desired manufacturing plan.

[0551] Input: Manufacturing plan displayed on the terminal.

[0552] Data processing: The user selects the manufacturing plan they deem most optimal and sends the selected information to the cloud server.

[0553] Output: The selected manufacturing plan.

[0554] Step 6:

[0555] The server updates the material information based on the selected manufacturing plan.

[0556] Input: The manufacturing plan selected by the user.

[0557] Data processing: Updates current material information based on the material consumption amount listed in the selected manufacturing plan.

[0558] Output: Updated ingredient information (e.g. "300g flour, 100g sugar").

[0559] These are the processing steps of the system program that realizes this application example. This automates material management and optimization of manufacturing plans within the factory, enabling efficient operation.

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

[0561] As an embodiment of the present invention, a specific implementation method of a system that inputs ingredients information of a user combined with an emotion engine and generates and displays suggested menus based on that information will be described.

[0562] User input of ingredient information

[0563] First, the user uses the device to input information about ingredients they have on hand. The device collects the types and quantities of the ingredients and organizes them into a dictionary. For example, if the user inputs "onions, 200g" and "carrots, 100g," the device organizes this information as follows:

[0564] python

[0565] {

[0566] 'Onion': '200g',

[0567] 'Carrots': '100g'

[0568] }

[0569] Acquiring user emotion information

[0570] The device is equipped with an emotion engine that recognizes the user's emotions in real time from their facial expressions and voice. This emotional information is taken into consideration when suggesting menu items.

[0571] Server-generated menu suggestions

[0572] Next, the device sends the collected ingredient information and the user's emotional information to the server. The server generates a suggested menu based on the received ingredient information and emotional information. The server uses an external API to create a recipe from this information. At this time, the server sets the ingredient information and emotional information as API prompts.

[0573] For example, set the prompt as follows:

[0574] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[0575] Let's say the API responds with a recipe for "Comforting Onion and Carrot Soup."

[0576] Display of suggestion menu by device

[0577] The server generates a suggested menu and sends it to the terminal. The terminal displays the received suggested menu to the user. The user can check the suggested menu on the terminal screen.

[0578] User selects menu and updates ingredient information

[0579] The user selects the desired menu from the displayed suggested menu. For example, suppose "onion and carrot soup" is selected. The selected menu is notified to the server by the terminal. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[0580] Specifically, we update the ingredient information based on the selected menu, assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0581] python

[0582] {

[0583] 'onion': '100g',

[0584] 'Carrots': '50g'

[0585] }

[0586] Update user emotion information

[0587] Furthermore, the emotion information is also updated based on the menu selected by the user. For example, if a specific menu is determined to have the effect of refreshing the user's mood, the emotion engine will update the user's emotion as "refreshed."

[0588] The updated ingredient information and emotion information are stored on the server and used the next time a menu is proposed. In this way, the system efficiently utilizes the ingredient information stored by the user, reduces waste, and responds to changes in the user's emotions.

[0589] The above is a specific embodiment for carrying out the present invention.

[0590] The processing flow will be explained below.

[0591] Step 1:

[0592] The user inputs information about ingredients they have on hand into the terminal. The user inputs the information in the format of "ingredient name, quantity", and when they have finished inputting all the information, they input "end" to complete the input.

[0593] Step 2:

[0594] The terminal collects ingredient information entered by the user. The collected information is organized in dictionary format, with the key being the ingredient name and the value being the quantity.

[0595] Step 3:

[0596] The device uses an emotion engine to collect the user's emotional information, evaluating the user's emotions in real time through facial expressions and voice analysis, and collecting this emotional information as independent data.

[0597] Step 4:

[0598] The terminal transmits the organized ingredient information and collected emotion information to the server, which then transmits the ingredient information and emotion information to the server via a network.

[0599] Step 5:

[0600] The server processes the ingredient information and emotion information received from the device. The received information is temporarily stored on the server.

[0601] Step 6:

[0602] The server generates a suggested menu based on the ingredient information and emotion information. The server calls an external recipe generation API and sets the ingredient information and emotion information as a prompt. For example, the prompt could be set as follows: "Please suggest a recipe using the following ingredients that matches the current user's emotion: {'onion': '200g', 'carrot': '100g'} User emotion: 'Feeling tired'."

[0603] Step 7:

[0604] The server receives the response from the API and retrieves the suggested menu. For example, if the API returns a recipe for "Relaxing Onion and Carrot Soup," the server retrieves this menu information.

[0605] Step 8:

[0606] The server sends the acquired proposal menu to the terminal, and the generated proposal menu is sent to the terminal via the network.

[0607] Step 9:

[0608] The terminal receives the proposed menu and displays it to the user, who can then check the proposed menu on the terminal screen.

[0609] Step 10:

[0610] The user selects the desired menu from the displayed suggested menu. For example, the user selects "onion and carrot soup." The selected menu is notified to the server by the terminal.

[0611] Step 11:

[0612] The server updates the ingredient information based on the user's selection. It calculates the ingredients used in the selected menu and their amounts, and updates the ingredient information assuming that, for example, 100g of onions and 50g of carrots were consumed. In this case, the updated data will look like this:

[0613] python

[0614] {

[0615] 'onion': '100g',

[0616] 'Carrots': '50g'

[0617] }

[0618] Step 12:

[0619] The server saves the updated ingredient information, which is then reused the next time a menu is generated.

[0620] Step 13:

[0621] The emotion engine updates the emotion information based on the user's selection. For example, if a particular menu item is determined to have a refreshing effect on the user's mood, the emotion engine updates the user's emotion as "refreshed."

[0622] Step 14:

[0623] The server stores the updated emotion information, so that the next time a menu suggestion is generated, the user's latest emotion state can be taken into account.

[0624] The above are the specific steps for carrying out the present invention, and the specific operations at each step have been explained in detail.

[0625] Example 2

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

[0627] Conventional ingredient management and recipe suggestion systems mainly display suggested menus based on ingredient information entered by the user, but have the problem of not being able to take into account individual states such as the user's emotions. Furthermore, while it is expected that more personalized suggestions will be possible by utilizing the user's emotional information when generating suggested menus, there has been a lack of means to achieve this.

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

[0629] In this invention, the server includes a means for a user to input ingredient information, a means for the terminal to organize the input ingredient information into dictionary format, a means for the terminal to acquire user emotional information, a means for the server to receive the emotional information and ingredient information, a means for the server to generate a suggested menu based on the ingredient information and emotional information received, a means for the terminal to display the generated suggested menu to the user, and a means for updating the ingredient information and emotional information based on the user's selection. This makes it possible to provide a more personalized suggested menu that takes into account the user's emotional information, which is expected to improve user satisfaction.

[0630] A "user" is an entity that uses this system to input ingredient information and emotional information and use the suggested menu.

[0631] A "terminal" is a device that a user accesses to input ingredient information, acquire emotional information, and display suggested menus.

[0632] The "server" is a central processing unit that generates menu suggestions based on the ingredient information and emotion information sent from the terminal.

[0633] An "emotion engine" is software or hardware that analyzes emotions from a user's facial expressions and voice in real time and acquires appropriate emotional information.

[0634] "Ingredient information" is data relating to the types and amounts of ingredients that the user owns.

[0635] A "suggested menu" is a cooking recipe that the server generates based on ingredient information and emotion information and presents to the user.

[0636] "External API" means an external application programming interface that the server uses to generate the suggestion menu.

[0637] The "dictionary format" is a data format that organizes ingredient information as key-value pairs and manages them efficiently.

[0638] "Update" is an operation for keeping ingredient information and emotion information up to date according to user selection.

[0639] "Real-time" is a time frame that means data is acquired and processed immediately.

[0640] As an embodiment of the present invention, a specific implementation method of a system that inputs ingredients information of a user combined with an emotion engine and generates and displays suggested menus based on that information will be described.

[0641] User input of ingredient information

[0642] First, the user uses the terminal to input information about ingredients they have on hand. The terminal collects the types and quantities of the ingredients entered and organizes them in dictionary format. For example, if the user enters "onions, 200g" and "carrots, 100g," the terminal organizes this information. Dictionary format is a data format that organizes ingredient information as key-value pairs and manages them efficiently. The terminal is designed to make it easy for users to input information using a GUI (Graphical User Interface).

[0643] Acquiring user emotion information

[0644] Next, the device is equipped with an emotion engine that recognizes emotions in real time from the user's facial expressions and voice. This emotional information is taken into consideration when suggesting recipes. The emotion engine acquires data, for example, through a camera or microphone, and analyzes it in real time. Examples of software used include OpenCV and DeepFace.

[0645] Server-generated menu suggestions

[0646] The device sends the collected ingredient information and the user's emotional information to the server. The server generates a suggested menu based on the received information. The server uses an external API to generate a recipe from this information. At this time, the server sets the ingredient information and emotional information as the API prompt. The prompt text is set as follows:

[0647] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[0648] Thus, the API might respond with a recipe for "Comforting Onion and Carrot Soup."

[0649] Display of suggestion menu by device

[0650] The server sends the generated suggested menu to the terminal. The terminal displays the received suggested menu to the user. The user can check the suggested menu on the terminal screen. The screen displays the recipe name, ingredients, steps, etc., allowing the user to intuitively select a menu.

[0651] User selects menu and updates ingredient information

[0652] The user selects the desired menu from the displayed suggested menu. For example, suppose "onion and carrot soup" is selected. The selected menu is notified to the server by the terminal. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount. For example, the ingredient information is updated assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the ingredient information is updated according to the selected menu.

[0653] Update user emotion information

[0654] Furthermore, the emotion information is also updated based on the menu selected by the user. For example, if a specific menu is determined to have the effect of refreshing the user's mood, the emotion engine updates the user's emotion to "refreshed." This updated emotion information is used when generating the next suggested menu.

[0655] In this way, a system is provided that efficiently utilizes the food ingredient information held by the user, reduces waste, and also responds to changes in the user's emotions.

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

[0657] Step 1: User enters ingredient information

[0658] The user launches the device app and inputs information about ingredients they have on hand through text boxes and drop-down lists. For example, they might input information like "onions, 200g" or "carrots, 100g." The device receives this information and converts it into a dictionary format. The dictionary format manages pairs of ingredient names as keys and quantities as values. For example, it can be formatted as follows:

[0659] python

[0660] {

[0661] 'Onion': '200g',

[0662] 'Carrots': '100g'

[0663] }

[0664] Input: Ingredient information entered by the user

[0665] Output: Ingredient information organized in dictionary format

[0666] Step 2: Obtaining user emotion information

[0667] The device's built-in emotion engine analyzes the user's facial expressions and voice in real time through the camera and microphone, using software libraries such as OpenCV and DeepFace. The analyzed emotion data is then classified as "tired" or "confused," for example.

[0668] Input: User facial and voice data acquired from camera and microphone

[0669] Output: Parsed emotion information

[0670] Step 3: Server generates suggestion menu

[0671] The device sends the organized ingredient information and analyzed emotion information to the server. The server receives them and generates a prompt. This prompt is set as a request to the external API. For example, the prompt is generated as follows:

[0672] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[0673] The server sends this prompt to an external recipe API, which generates an appropriate recipe and returns it to the server.

[0674] Input: Ingredient information and emotional information sent from the device

[0675] Output: Suggestion menu returned from external API

[0676] Step 4: Display the suggestion menu by device

[0677] The server sends the suggested menu received from the external API to the device. The device receives this information and displays it to the user. The screen displays the recipe name, ingredients, steps, etc. For example, it displays a recipe for "Relaxing Onion and Carrot Soup."

[0678] Input: Suggestion menu sent from the server

[0679] Output: The suggestion menu displayed to the user

[0680] Step 5: User selects menu and updates ingredients

[0681] The user selects the desired menu from the suggested menu. Once the selection is made, the device notifies the server of the selection. The server updates the ingredient information based on the selected menu. For example, let's assume that "100g of onions" and "50g of carrots" are used. The updated ingredient information will be as follows:

[0682] python

[0683] {

[0684] 'onion': '100g',

[0685] 'Carrots': '50g'

[0686] }

[0687] Input: Menu information selected by the user

[0688] Output: Updated ingredient information

[0689] Step 6: Update user's emotion information

[0690] The emotion engine is then run again to evaluate the impact of the selected menu on the user's emotions. For example, if the selected menu is determined to be "refreshed," the new emotion information is notified to the server and updated. This ensures that the latest emotion information is taken into account when suggesting a menu next time.

[0691] Input: User menu choices and their impact

[0692] Output: Updated emotion information

[0693] These processing steps realize a system that provides personalized menu suggestions based on the user's ingredient information and emotional information.

[0694] (Application example 2)

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

[0696] Conventional menu suggestion generation systems are unable to take the user's emotions into account, making it impossible to suggest appropriate menus that reflect the user's mental state at any given time. Furthermore, managing the user's ingredient information is cumbersome, making it difficult to suggest efficient menus. There is a need for a system that can overcome these drawbacks and make efficient menu suggestions while taking the user's emotional information into account.

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

[0698] In this invention, the server includes a means for a user to input ingredient information, a means for generating a suggested menu based on the ingredient information and emotion information received by the server, a means for displaying the generated suggested menu to the user, a means for updating the ingredient information based on the user's selection, and a means for acquiring the user's emotion information using an emotion engine built into the terminal. This makes it possible to propose an optimal menu based on the user's emotion information and efficiently manage ingredient information.

[0699] "Ingredient information" is information that indicates the types and amounts of ingredients that the user has on hand.

[0700] A "suggested menu" refers to a recipe or menu of food that is generated by the server based on the ingredient information and emotion information entered by the user.

[0701] "Emotion information" is information about the user's mental state that the emotion engine obtains in real time from the user's facial expressions and voice.

[0702] An "emotion engine" is an engine that analyzes the user's facial expressions and voice to recognize and acquire their emotions in real time.

[0703] An "external API" is an external application programming interface for generating a suggestion menu based on a request from a server.

[0704] A "terminal" is a device (such as a smartphone or tablet) that allows a user to input ingredient information, acquire emotion information, and display suggested menus.

[0705] In this embodiment, a system is used in which a server, a terminal, and a user each play their respective roles. Here, we will explain in detail the process of inputting information about ingredients and emotions from the user, and generating and displaying the optimal menu suggestions based on that information.

[0706] First, the user uses a device (such as a smartphone or tablet) to input information about ingredients they have on hand. The device collects the types and quantities of the ingredients entered and organizes them in dictionary format. For example, if a user enters "tomatoes, 200g" and "chicken, 150g," the device organizes this information and sends it to the server. The server receives and analyzes this information.

[0707] Next, the device is equipped with an emotion engine that recognizes emotional information in real time from the user's facial expressions, voice, etc. This emotional information is also sent to the server and analyzed together with the ingredient information.

[0708] The server generates a suggested menu based on the received ingredient information and emotion information. The server uses an external API to generate the optimal recipe from this information. In this case, the server sets the ingredient information and emotion information as a prompt. Specifically, the server uses the following prompt text:

[0709] "Suggest a recipe using the following ingredients and matching the user's current emotion: {'tomato': '200g', 'chicken': '150g'} User emotion: 'stressed'"

[0710] Based on this prompt, the generative AI model responds with a suggested menu item (e.g., "Relaxed salad with tomatoes and chicken").

[0711] The generated suggested menu is sent from the server to the terminal, which displays it to the user. The user checks the suggested menu on the terminal screen and selects the desired menu. The selected menu is notified to the server by the terminal, and the server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[0712] For example, if a user selects "Relaxed Tomato and Chicken Salad" and the menu requires "100g of tomatoes and 50g of chicken," the server updates the ingredient information and stores "100g of tomatoes and 100g of chicken" as new data.

[0713] Furthermore, the emotion information is also updated based on the selected menu. If a particular menu is determined to have an effect of improving the user's mood, the emotion engine updates the user's emotion information as "refreshed."

[0714] In this way, it is possible to provide a system that efficiently utilizes the ingredient information held by the user, reduces waste, and also responds to changes in the user's emotions.

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

[0716] Step 1:

[0717] The user uses the terminal to input information about ingredients they have on hand. The type and amount of the ingredients entered become input data, and the terminal organizes this into a dictionary format. For example, inputs such as "tomato, 200g" and "chicken, 150g" are organized as "{'tomato': '200g', 'chicken': '150g'}". The organized data is then sent directly to the server.

[0718] Step 2:

[0719] The emotion engine built into the device analyzes the user's facial expressions and voice in real time to obtain the user's emotional information. For example, if the user is feeling stressed, the emotion information extracted will be "feeling stressed." The obtained emotion information is also sent to the server.

[0720] Step 3:

[0721] The server generates a suggested menu based on the received ingredient information and emotion information. Specifically, it sets the ingredient information and emotion information as a prompt and sends a request to an external API equipped with a generative AI model. The server receives the optimal recipe as a response from the external API. For example, the prompt text could be "Please suggest a recipe using the following ingredients that matches the user's current emotion: {'tomato': '200g', 'chicken': '150g'} User emotion: 'I'm feeling stressed'."

[0722] Step 4:

[0723] The server receives a menu suggestion generated from an external API (e.g., "Relaxed salad with tomatoes and chicken") and sends it to the device. The device displays the menu suggestion to the user.

[0724] Step 5:

[0725] The user checks the suggested menu displayed on the device and selects the desired menu item. For example, they select "Relaxed Tomato and Chicken Salad." The selected menu item is notified to the server from the device.

[0726] Step 6:

[0727] The server updates the ingredient information based on the ingredient consumption amounts corresponding to the selected menu. For example, if "100g of tomatoes and 50g of chicken" are consumed, the server updates the ingredient information to "100g of tomatoes and 100g of chicken." The updated information is saved on the server and will be used the next time a suggested menu is generated.

[0728] Step 7:

[0729] Furthermore, the emotional information is updated based on the impact of the selected menu on the user's emotions. For example, the emotional state is updated to "refreshed." The emotion engine recognizes this data and sends it to the server. The new emotional information is also saved on the server and used for the next suggestion.

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

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

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

[0733] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0746] As an embodiment of the present invention, a specific implementation method of a system in which a user inputs ingredient information held by the user and generates and displays the most suitable suggested menu based on that information will be described.

[0747] User input of ingredient information

[0748] First, the user inputs the ingredients they have on hand using the device. The device collects the types and quantities of the ingredients and organizes them into a dictionary. For example, if the user inputs "onions, 200g" and "carrots, 100g", the device organizes this information as follows:

[0749] python

[0750] {

[0751] 'Onion': '200g',

[0752] 'Carrots': '100g'

[0753] }

[0754] Server-generated menu suggestions

[0755] Next, the device sends the collected ingredient information to the server. The server generates a suggested menu based on the received ingredient information. The server uses an external API to create a recipe from the ingredient information. At this time, the server sets the ingredient information as an API prompt and generates the optimal menu based on the API response.

[0756] Specifically, you can send a prompt like this to the API:

[0757] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0758] Let's say the API returns a recipe for "onion and carrot soup."

[0759] Display of suggestion menu by device

[0760] The server generates a proposed menu and sends it to the terminal. The terminal displays the received proposed menu to the user. The user can check the proposed menu on the terminal.

[0761] User selects menu and updates ingredient information

[0762] The user selects the desired menu from the displayed suggested menu. For example, "onion and carrot soup" is selected. The device sends this selection information to the server. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[0763] Specifically, we update the ingredient information based on the selected menu, assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0764] python

[0765] {

[0766] 'onion': '100g',

[0767] 'Carrots': '50g'

[0768] }

[0769] The updated ingredient information is stored on the server and used the next time a menu is proposed. In this way, a system is provided that can efficiently utilize the ingredient information stored by the user and reduce waste.

[0770] The above is a specific embodiment for carrying out the present invention.

[0771] The processing flow will be explained below.

[0772] Step 1:

[0773] The user inputs the information about ingredients they have on hand into the terminal. Specifically, the user inputs the information in the format of "ingredient name, quantity", and when all the information has been input, the user enters "end" to finish.

[0774] Step 2:

[0775] The terminal collects ingredient information entered by the user. The collected information is organized in dictionary format, with the key being the ingredient name and the value being the quantity.

[0776] Step 3:

[0777] The terminal sends the organized ingredient information to the server, which then sends the ingredient information from the terminal to the server via the network.

[0778] Step 4:

[0779] The server processes the ingredient information received from the terminal, and the received information is temporarily stored on the server.

[0780] Step 5:

[0781] The server generates a suggested menu based on the received ingredient information. To achieve this, the server calls an external recipe generation API and sets the ingredient information as a prompt.

[0782] Step 6:

[0783] The server receives a response from the API, which includes suggested menus and recipes.

[0784] Step 7:

[0785] The server sends the proposed menu to the terminal, and the generated proposed menu is sent to the terminal via the network.

[0786] Step 8:

[0787] The terminal receives the proposed menu and displays it to the user, who can then check the proposed menu on the terminal screen.

[0788] Step 9:

[0789] The user selects the desired menu from the proposed menu, and the selected menu is notified to the server by the terminal.

[0790] Step 10:

[0791] The server updates the ingredient information based on the user's selection, specifically by calculating and updating the ingredients and amounts used in the selected menu.

[0792] Step 11:

[0793] The server saves the updated ingredient information, which is then reused the next time a menu is generated.

[0794] The above is a detailed explanation of the processing steps in this system, and the specific operations at each step have been explained in an easy-to-understand manner.

[0795] Example 1

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

[0797] In today's world, reducing food waste and using it efficiently is an important issue. However, there are only a limited number of systems that allow users to manage information about ingredients on hand and suggest appropriate menus based on that information. Conventional methods often require users to manually manage ingredient information and spend time thinking up recipe ideas. Furthermore, there are few systems that automatically update ingredient information based on suggested menus, which can easily lead to food waste. There is a need to provide a system that solves these problems.

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

[0799] In this invention, the server includes means for a user to input ingredient information, means for the terminal to organize the input ingredient information into dictionary format, means for the terminal to send the organized ingredient information to the server, means for the server to generate a suggested menu by sending a prompt to an external API based on the ingredient information received, means for displaying the generated suggested menu to the user, means for updating the ingredient information based on the user's selection, and means for using the updated ingredient information to generate the next suggested menu. This allows users to efficiently manage their available ingredient information and easily obtain suggested menus that make the most of ingredients without waste.

[0800] "User" refers to an individual who uses this system to input and manage ingredient information and receive suggested menus.

[0801] "Terminal" refers to an electronic device that a user uses to input ingredient information and that displays suggested menus.

[0802] "Ingredient information" refers to data that indicates the types and amounts of ingredients that a user owns.

[0803] "Dictionary format" refers to a method of organizing data using key-value pairs, specifically a format in which the names of ingredients are the keys and the quantities are the values.

[0804] The term "server" refers to a computer processing device that receives ingredient information sent from a terminal, generates menu suggestions based on that information, and sends the results to the terminal.

[0805] "External API" refers to an external application programming interface that the Server utilizes to generate the suggestion menu.

[0806] "Prompt text" refers to the explanatory text used when making a specific request to an external API.

[0807] "Suggested menu" refers to suggestions for recipes and dishes that the user can cook based on the input ingredient information.

[0808] "Update" refers to the act of updating ingredient information to the latest version based on the user's selection.

[0809] "Next time" refers to a future operation or use that follows the current operation.

[0810] The embodiments of the present invention will be specifically described below.

[0811] First, the user inputs ingredient information using their own device. The device collects the input ingredient information and organizes it in dictionary format. For example, if the user inputs "200g of onions" and "100g of carrots," the device converts this information into dictionary format and creates data organized as follows:

[0812] python

[0813] {

[0814] 'Onion': '200g',

[0815] 'Carrots': '100g'

[0816] }

[0817] Next, the device sends the organized ingredient information to the server. This is generally done using an HTTP request. The server uses an external API to generate menu suggestions based on the received ingredient information. The server sets the ingredient information as a prompt and sends a request to the external API. For example, the following prompt is sent to the external API:

[0818] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0819] The external API receives this prompt, creates a menu of suggestions based on that information, and returns a response to the server, such as a recipe for "onion and carrot soup."

[0820] The server analyzes the returned recipe information, generates a suggested menu that is optimal for the user, and sends it to the terminal. The terminal displays the suggested menu received from the server to the user. The user can check the suggested menu on the terminal and select the desired menu.

[0821] Furthermore, when the user selects the desired menu item, the device sends the selection information to the server. The server then updates the ingredient information based on the selected menu item. For example, the ingredient information is updated assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0822] python

[0823] {

[0824] 'onion': '100g',

[0825] 'Carrots': '50g'

[0826] }

[0827] The updated ingredient information is stored on the server and will be used the next time a menu is proposed.

[0828] This system allows users to efficiently manage information about ingredients on hand and easily obtain suggested menus that utilize ingredients without waste, thereby reducing food waste and providing a system that makes users' lives more convenient.

[0829] The above is a specific embodiment for carrying out the present invention.

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

[0831] Step 1:

[0832] The user uses the terminal to input information about ingredients they have on hand. For example, the user enters "200g of onions" and "100g of carrots" into the terminal's input form. This input information is the data that will be used as the basis for the next processing step.

[0833] Step 2:

[0834] The terminal collects the entered ingredient information and organizes it in dictionary format. For example, "200g of onions" and "100g of carrots" are converted into dictionary format as key-value pairs. Specifically, the data obtained from the form is converted into dictionary format within the program.

[0835] Step 3:

[0836] The device sends the organized ingredient information to the server. An HTTP request is used for transmission, and the ingredient information is sent in JSON format. At this time, the input dictionary-format data is sent to the server, allowing it to be processed on the server side.

[0837] Step 4:

[0838] The server generates a suggested menu based on the received ingredient information. To do this, the server uses an external API. Specifically, the server converts the ingredient information into a prompt and sends a request to the external API. In response to this request, the API returns the corresponding recipe information.

[0839] Step 5:

[0840] When creating the prompt, the server converts the data into a format such as:

[0841] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[0842] By sending this prompt to the API, the appropriate recipe will be returned as a response.

[0843] Step 6:

[0844] The external API generates a recipe based on the received prompt and returns it to the server. For example, a recipe such as "onion and carrot soup" is returned. This information is received and analyzed on the server side.

[0845] Step 7:

[0846] The server analyzes the returned recipe information and generates a menu of suggestions, which are formatted in a way that is meaningful to the user and ready to be sent to the user in the next processing step.

[0847] Step 8:

[0848] The server sends the generated suggested menu to the terminal, and the terminal displays the received suggested menu to the user, who can then check the suggested menu on the terminal.

[0849] Step 9:

[0850] The user selects the desired menu from the displayed menu of suggestions, for example, "onion and carrot soup." This selection information is the basis for the next processing step.

[0851] Step 10:

[0852] The terminal transmits the user's selection information to the server. The transmission of the selected menu information to the server starts the processing in the next step.

[0853] Step 11:

[0854] The server updates the ingredient information based on the selected menu. Specifically, it updates the ingredient information it holds, assuming that "100g of onions" and "50g of carrots" have been consumed based on the selected menu. After the update, the ingredient information is kept up to date.

[0855] Step 12:

[0856] The updated ingredient information is stored on the server and used the next time a menu is proposed. This ensures that the ingredient information held by the user is always up-to-date, reducing waste.

[0857] The above is the flow of specific processing steps of this system.

[0858] (Application example 1)

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

[0860] In modern food manufacturing factories, reducing material waste and optimizing production plans are serious challenges. It is particularly difficult to efficiently manage the large amounts of materials used within the factory and consistently provide optimal production plans. This can lead to overpurchasing and waste of materials, which can increase manufacturing costs and reduce production efficiency. To solve these issues, a system is needed that can accurately grasp material information within the factory and automatically generate and provide optimal production plans based on that information.

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

[0862] In this invention, the server includes a means for a user to input ingredient information, a means for generating a proposed plan based on the ingredient information received by the server, and a means for displaying the generated proposed plan to the user. This allows factory robots to collect ingredient information and transmit the data to the cloud server, enabling production planning. Furthermore, by providing a means for updating ingredient information based on user selections, it is possible to reduce ingredient waste and consistently provide efficient production plans.

[0863] "Ingredient information" is data regarding the type and amount of food entered by the user.

[0864] "Proposed plan" refers to the optimal menu and production plan generated based on the input ingredient information.

[0865] "User" refers to the person who uses the system to input ingredient information and check and select the proposed plan, or the entity that operates the system.

[0866] "Server" refers to a computing device that receives ingredient information and generates and provides proposed plans.

[0867] A "factory robot" refers to an automated mechanical device that collects material information within a factory.

[0868] A "cloud server" is a remote server connected via the Internet that processes and stores data.

[0869] "Data transmission" refers to the process by which factory robots send collected material information to a cloud server.

[0870] "Manufacturing planning" refers to determining the optimal manufacturing process and work plan based on collected material information.

[0871] "Update" refers to the process of updating ingredient information to the latest version based on the user's selection.

[0872] As an embodiment of the present invention, a system will be described that utilizes factory robots in a food manufacturing factory to efficiently perform operations from collecting ingredient information to proposing a manufacturing plan and updating food ingredient information.

[0873] First, the factory robot collects information about the ingredients used in the factory. Specifically, it obtains the type and quantity of ingredients from sensors installed on the ingredient shelves and organizes them as food types and their quantities. For example, if there is 500g of flour and 200g of sugar, this information is collected in dictionary format.

[0874] Next, the device sends the collected material information to the cloud server. Based on the received material information, the cloud server uses a generative AI model to propose an optimal manufacturing plan. To use the generative AI model, the cloud server calls an external API and sets the material information as a prompt. Specifically, it sends the following prompt:

[0875] "Please propose a recipe using the following ingredients: 500g flour, 200g sugar, 100g butter."

[0876] The cloud server then receives the optimal manufacturing plan returned by the API and sends it to the device. The user can then review the proposed manufacturing plans on their device and select the one they prefer. The selected plan is then sent back to the cloud server, which calculates the amount of material consumed based on the selected plan and updates the material information.

[0877] For example, if a user selects a production plan that uses 200g of flour and 100g of sugar, the cloud server recalculates the new ingredient information, updating the flour to 300g and sugar to 100g. This updated information is used for the next menu generation.

[0878] This system enables food manufacturing factories to significantly reduce material waste and consistently provide efficient and optimal production plans. The specific hardware used includes sensors installed on material shelves, factory robots, and smartphones or tablets as terminals, while the cloud server requires an internet connection. The software used is Raspberry Pi or Arduino for sensor data collection, and Amazon Web Services or Google Cloud Platform for the cloud server.

[0879] This will enable consistent material management and optimal production plans across the entire system, which is expected to significantly improve production efficiency in food manufacturing factories.

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

[0881] Step 1:

[0882] Factory robots collect material information.

[0883] Input: Data from sensors installed on material shelves.

[0884] Data processing: The data obtained from the sensors is organized into material types and quantities and converted into dictionary format.

[0885] Output: Collected ingredient information (e.g. "500g flour, 200g sugar").

[0886] Step 2:

[0887] The terminal sends material information to the cloud server.

[0888] Input: Material information collected and organized by factory robots.

[0889] Data processing: Material information is converted into JSON format and sent to the cloud server.

[0890] Output: Material information sent to the cloud server.

[0891] Step 3:

[0892] Based on the material information received by the server, a generative AI model is used to generate a proposed plan.

[0893] Input: Material information received by the cloud server.

[0894] Data processing: Send material information as prompts to an external API and use a generative AI model to obtain the optimal manufacturing plan.

[0895] Output: The generated production plan (e.g. "Production plan using 200g flour and 100g sugar").

[0896] Step 4:

[0897] The server transmits the generated manufacturing plan to the terminal, which displays it to the user.

[0898] Input: Generated manufacturing plan.

[0899] Data processing: The generated manufacturing plan is formatted into a form that is easy for users to understand.

[0900] Output: Manufacturing plan that the user sees on the terminal.

[0901] Step 5:

[0902] The user selects the desired manufacturing plan.

[0903] Input: Manufacturing plan displayed on the terminal.

[0904] Data processing: The user selects the manufacturing plan they deem most optimal and sends the selected information to the cloud server.

[0905] Output: The selected manufacturing plan.

[0906] Step 6:

[0907] The server updates the material information based on the selected manufacturing plan.

[0908] Input: The manufacturing plan selected by the user.

[0909] Data processing: Updates current material information based on the material consumption amount listed in the selected manufacturing plan.

[0910] Output: Updated ingredient information (e.g. "300g flour, 100g sugar").

[0911] These are the processing steps of the system program that realizes this application example. This automates material management and optimization of manufacturing plans within the factory, enabling efficient operation.

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

[0913] As an embodiment of the present invention, a specific implementation method of a system that inputs ingredients information of a user combined with an emotion engine and generates and displays suggested menus based on that information will be described.

[0914] User input of ingredient information

[0915] First, the user uses the device to input information about ingredients they have on hand. The device collects the types and quantities of the ingredients and organizes them into a dictionary. For example, if the user inputs "onions, 200g" and "carrots, 100g," the device organizes this information as follows:

[0916] python

[0917] {

[0918] 'Onion': '200g',

[0919] 'Carrots': '100g'

[0920] }

[0921] Acquiring user emotion information

[0922] The device is equipped with an emotion engine that recognizes the user's emotions in real time from their facial expressions and voice. This emotional information is taken into consideration when suggesting menu items.

[0923] Server-generated menu suggestions

[0924] Next, the device sends the collected ingredient information and the user's emotional information to the server. The server generates a suggested menu based on the received ingredient information and emotional information. The server uses an external API to create a recipe from this information. At this time, the server sets the ingredient information and emotional information as API prompts.

[0925] For example, set the prompt as follows:

[0926] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[0927] Let's say the API responds with a recipe for "Comforting Onion and Carrot Soup."

[0928] Display of suggestion menu by device

[0929] The server generates a suggested menu and sends it to the terminal. The terminal displays the received suggested menu to the user. The user can check the suggested menu on the terminal screen.

[0930] User selects menu and updates ingredient information

[0931] The user selects the desired menu from the displayed suggested menu. For example, suppose "onion and carrot soup" is selected. The selected menu is notified to the server by the terminal. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[0932] Specifically, we update the ingredient information based on the selected menu, assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[0933] python

[0934] {

[0935] 'onion': '100g',

[0936] 'Carrots': '50g'

[0937] }

[0938] Update user emotion information

[0939] Furthermore, the emotion information is also updated based on the menu selected by the user. For example, if a specific menu is determined to have the effect of refreshing the user's mood, the emotion engine will update the user's emotion as "refreshed."

[0940] The updated ingredient information and emotion information are stored on the server and used the next time a menu is proposed. In this way, the system efficiently utilizes the ingredient information stored by the user, reduces waste, and responds to changes in the user's emotions.

[0941] The above is a specific embodiment for carrying out the present invention.

[0942] The processing flow will be explained below.

[0943] Step 1:

[0944] The user inputs information about ingredients they have on hand into the terminal. The user inputs the information in the format of "ingredient name, quantity", and when they have finished inputting all the information, they input "end" to complete the input.

[0945] Step 2:

[0946] The terminal collects ingredient information entered by the user. The collected information is organized in dictionary format, with the key being the ingredient name and the value being the quantity.

[0947] Step 3:

[0948] The device uses an emotion engine to collect the user's emotional information, evaluating the user's emotions in real time through facial expressions and voice analysis, and collecting this emotional information as independent data.

[0949] Step 4:

[0950] The terminal transmits the organized ingredient information and collected emotion information to the server, which then transmits the ingredient information and emotion information to the server via a network.

[0951] Step 5:

[0952] The server processes the ingredient information and emotion information received from the device. The received information is temporarily stored on the server.

[0953] Step 6:

[0954] The server generates a suggested menu based on the ingredient information and emotion information. The server calls an external recipe generation API and sets the ingredient information and emotion information as a prompt. For example, the prompt could be set as follows: "Please suggest a recipe using the following ingredients that matches the current user's emotion: {'onion': '200g', 'carrot': '100g'} User emotion: 'Feeling tired'."

[0955] Step 7:

[0956] The server receives the response from the API and retrieves the suggested menu. For example, if the API returns a recipe for "Relaxing Onion and Carrot Soup," the server retrieves this menu information.

[0957] Step 8:

[0958] The server sends the acquired proposal menu to the terminal, and the generated proposal menu is sent to the terminal via the network.

[0959] Step 9:

[0960] The terminal receives the proposed menu and displays it to the user, who can then check the proposed menu on the terminal screen.

[0961] Step 10:

[0962] The user selects the desired menu from the displayed suggested menu. For example, the user selects "onion and carrot soup." The selected menu is notified to the server by the terminal.

[0963] Step 11:

[0964] The server updates the ingredient information based on the user's selection. It calculates the ingredients used in the selected menu and their amounts, and updates the ingredient information assuming that, for example, 100g of onions and 50g of carrots were consumed. In this case, the updated data will look like this:

[0965] python

[0966] {

[0967] 'onion': '100g',

[0968] 'Carrots': '50g'

[0969] }

[0970] Step 12:

[0971] The server saves the updated ingredient information, which is then reused the next time a menu is generated.

[0972] Step 13:

[0973] The emotion engine updates the emotion information based on the user's selection. For example, if a particular menu item is determined to have a refreshing effect on the user's mood, the emotion engine updates the user's emotion as "refreshed."

[0974] Step 14:

[0975] The server stores the updated emotion information, so that the next time a menu suggestion is generated, the user's latest emotion state can be taken into account.

[0976] The above are the specific steps for carrying out the present invention, and the specific operations at each step have been explained in detail.

[0977] Example 2

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

[0979] Conventional ingredient management and recipe suggestion systems mainly display suggested menus based on ingredient information entered by the user, but have the problem of not being able to take into account individual states such as the user's emotions. Furthermore, while it is expected that more personalized suggestions will be possible by utilizing the user's emotional information when generating suggested menus, there has been a lack of means to achieve this.

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

[0981] In this invention, the server includes a means for a user to input ingredient information, a means for the terminal to organize the input ingredient information into dictionary format, a means for the terminal to acquire user emotional information, a means for the server to receive the emotional information and ingredient information, a means for the server to generate a suggested menu based on the ingredient information and emotional information received, a means for the terminal to display the generated suggested menu to the user, and a means for updating the ingredient information and emotional information based on the user's selection. This makes it possible to provide a more personalized suggested menu that takes into account the user's emotional information, which is expected to improve user satisfaction.

[0982] A "user" is an entity that uses this system to input ingredient information and emotional information and use the suggested menu.

[0983] A "terminal" is a device that a user accesses to input ingredient information, acquire emotional information, and display suggested menus.

[0984] The "server" is a central processing unit that generates menu suggestions based on the ingredient information and emotion information sent from the terminal.

[0985] An "emotion engine" is software or hardware that analyzes emotions from a user's facial expressions and voice in real time and acquires appropriate emotional information.

[0986] "Ingredient information" is data relating to the types and amounts of ingredients that the user owns.

[0987] A "suggested menu" is a cooking recipe that the server generates based on ingredient information and emotion information and presents to the user.

[0988] "External API" means an external application programming interface that the server uses to generate the suggestion menu.

[0989] The "dictionary format" is a data format that organizes ingredient information as key-value pairs and manages them efficiently.

[0990] "Update" is an operation for keeping ingredient information and emotion information up to date according to user selection.

[0991] "Real-time" is a time frame that means data is acquired and processed immediately.

[0992] As an embodiment of the present invention, a specific implementation method of a system that inputs ingredients information of a user combined with an emotion engine and generates and displays suggested menus based on that information will be described.

[0993] User input of ingredient information

[0994] First, the user uses the terminal to input information about ingredients they have on hand. The terminal collects the types and quantities of the ingredients entered and organizes them in dictionary format. For example, if the user enters "onions, 200g" and "carrots, 100g," the terminal organizes this information. Dictionary format is a data format that organizes ingredient information as key-value pairs and manages them efficiently. The terminal is designed to make it easy for users to input information using a GUI (Graphical User Interface).

[0995] Acquiring user emotion information

[0996] Next, the device is equipped with an emotion engine that recognizes emotions in real time from the user's facial expressions and voice. This emotional information is taken into consideration when suggesting recipes. The emotion engine acquires data, for example, through a camera or microphone, and analyzes it in real time. Examples of software used include OpenCV and DeepFace.

[0997] Server-generated menu suggestions

[0998] The device sends the collected ingredient information and the user's emotional information to the server. The server generates a suggested menu based on the received information. The server uses an external API to generate a recipe from this information. At this time, the server sets the ingredient information and emotional information as the API prompt. The prompt text is set as follows:

[0999] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[1000] Thus, the API might respond with a recipe for "Comforting Onion and Carrot Soup."

[1001] Display of suggestion menu by device

[1002] The server sends the generated suggested menu to the terminal. The terminal displays the received suggested menu to the user. The user can check the suggested menu on the terminal screen. The screen displays the recipe name, ingredients, steps, etc., allowing the user to intuitively select a menu.

[1003] User selects menu and updates ingredient information

[1004] The user selects the desired menu from the displayed suggested menu. For example, suppose "onion and carrot soup" is selected. The selected menu is notified to the server by the terminal. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount. For example, the ingredient information is updated assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the ingredient information is updated according to the selected menu.

[1005] Update user emotion information

[1006] Furthermore, the emotion information is also updated based on the menu selected by the user. For example, if a specific menu is determined to have the effect of refreshing the user's mood, the emotion engine updates the user's emotion to "refreshed." This updated emotion information is used when generating the next suggested menu.

[1007] In this way, a system is provided that efficiently utilizes the food ingredient information held by the user, reduces waste, and also responds to changes in the user's emotions.

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

[1009] Step 1: User enters ingredient information

[1010] The user launches the device app and inputs information about ingredients they have on hand through text boxes and drop-down lists. For example, they might input information like "onions, 200g" or "carrots, 100g." The device receives this information and converts it into a dictionary format. The dictionary format manages pairs of ingredient names as keys and quantities as values. For example, it can be formatted as follows:

[1011] python

[1012] {

[1013] 'Onion': '200g',

[1014] 'Carrots': '100g'

[1015] }

[1016] Input: Ingredient information entered by the user

[1017] Output: Ingredient information organized in dictionary format

[1018] Step 2: Obtaining user emotion information

[1019] The device's built-in emotion engine analyzes the user's facial expressions and voice in real time through the camera and microphone, using software libraries such as OpenCV and DeepFace. The analyzed emotion data is then classified as "tired" or "confused," for example.

[1020] Input: User facial and voice data acquired from camera and microphone

[1021] Output: Parsed emotion information

[1022] Step 3: Server generates suggestion menu

[1023] The device sends the organized ingredient information and analyzed emotion information to the server. The server receives them and generates a prompt. This prompt is set as a request to the external API. For example, the prompt is generated as follows:

[1024] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[1025] The server sends this prompt to an external recipe API, which generates an appropriate recipe and returns it to the server.

[1026] Input: Ingredient information and emotional information sent from the device

[1027] Output: Suggestion menu returned from external API

[1028] Step 4: Display the suggestion menu by device

[1029] The server sends the suggested menu received from the external API to the device. The device receives this information and displays it to the user. The screen displays the recipe name, ingredients, steps, etc. For example, it displays a recipe for "Relaxing Onion and Carrot Soup."

[1030] Input: Suggestion menu sent from the server

[1031] Output: The suggestion menu displayed to the user

[1032] Step 5: User selects menu and updates ingredients

[1033] The user selects the desired menu from the suggested menu. Once the selection is made, the device notifies the server of the selection. The server updates the ingredient information based on the selected menu. For example, let's assume that "100g of onions" and "50g of carrots" are used. The updated ingredient information will be as follows:

[1034] python

[1035] {

[1036] 'onion': '100g',

[1037] 'Carrots': '50g'

[1038] }

[1039] Input: Menu information selected by the user

[1040] Output: Updated ingredient information

[1041] Step 6: Update user's emotion information

[1042] The emotion engine is then run again to evaluate the impact of the selected menu on the user's emotions. For example, if the selected menu is determined to be "refreshed," the new emotion information is notified to the server and updated. This ensures that the latest emotion information is taken into account when suggesting a menu next time.

[1043] Input: User menu choices and their impact

[1044] Output: Updated emotion information

[1045] These processing steps realize a system that provides personalized menu suggestions based on the user's ingredient information and emotional information.

[1046] (Application example 2)

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

[1048] Conventional menu suggestion generation systems are unable to take the user's emotions into account, making it impossible to suggest appropriate menus that reflect the user's mental state at any given time. Furthermore, managing the user's ingredient information is cumbersome, making it difficult to suggest efficient menus. There is a need for a system that can overcome these drawbacks and make efficient menu suggestions while taking the user's emotional information into account.

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

[1050] In this invention, the server includes a means for a user to input ingredient information, a means for generating a suggested menu based on the ingredient information and emotion information received by the server, a means for displaying the generated suggested menu to the user, a means for updating the ingredient information based on the user's selection, and a means for acquiring the user's emotion information using an emotion engine built into the terminal. This makes it possible to propose an optimal menu based on the user's emotion information and efficiently manage ingredient information.

[1051] "Ingredient information" is information that indicates the types and amounts of ingredients that the user has on hand.

[1052] A "suggested menu" refers to a recipe or menu of food that is generated by the server based on the ingredient information and emotion information entered by the user.

[1053] "Emotion information" is information about the user's mental state that the emotion engine obtains in real time from the user's facial expressions and voice.

[1054] An "emotion engine" is an engine that analyzes the user's facial expressions and voice to recognize and acquire their emotions in real time.

[1055] An "external API" is an external application programming interface for generating a suggestion menu based on a request from a server.

[1056] A "terminal" is a device (such as a smartphone or tablet) that allows a user to input ingredient information, acquire emotion information, and display suggested menus.

[1057] In this embodiment, a system is used in which a server, a terminal, and a user each play their respective roles. Here, we will explain in detail the process of inputting information about ingredients and emotions from the user, and generating and displaying the optimal menu suggestions based on that information.

[1058] First, the user uses a device (such as a smartphone or tablet) to input information about ingredients they have on hand. The device collects the types and quantities of the ingredients entered and organizes them in dictionary format. For example, if a user enters "tomatoes, 200g" and "chicken, 150g," the device organizes this information and sends it to the server. The server receives and analyzes this information.

[1059] Next, the device is equipped with an emotion engine that recognizes emotional information in real time from the user's facial expressions, voice, etc. This emotional information is also sent to the server and analyzed together with the ingredient information.

[1060] The server generates a suggested menu based on the received ingredient information and emotion information. The server uses an external API to generate the optimal recipe from this information. In this case, the server sets the ingredient information and emotion information as a prompt. Specifically, the server uses the following prompt text:

[1061] "Suggest a recipe using the following ingredients and matching the user's current emotion: {'tomato': '200g', 'chicken': '150g'} User emotion: 'stressed'"

[1062] Based on this prompt, the generative AI model responds with a suggested menu item (e.g., "Relaxed salad with tomatoes and chicken").

[1063] The generated suggested menu is sent from the server to the terminal, which displays it to the user. The user checks the suggested menu on the terminal screen and selects the desired menu. The selected menu is notified to the server by the terminal, and the server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[1064] For example, if a user selects "Relaxed Tomato and Chicken Salad" and the menu requires "100g of tomatoes and 50g of chicken," the server updates the ingredient information and stores "100g of tomatoes and 100g of chicken" as new data.

[1065] Furthermore, the emotion information is also updated based on the selected menu. If a particular menu is determined to have an effect of improving the user's mood, the emotion engine updates the user's emotion information as "refreshed."

[1066] In this way, it is possible to provide a system that efficiently utilizes the ingredient information held by the user, reduces waste, and also responds to changes in the user's emotions.

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

[1068] Step 1:

[1069] The user uses the terminal to input information about ingredients they have on hand. The type and amount of the ingredients entered become input data, and the terminal organizes this into a dictionary format. For example, inputs such as "tomato, 200g" and "chicken, 150g" are organized as "{'tomato': '200g', 'chicken': '150g'}". The organized data is then sent directly to the server.

[1070] Step 2:

[1071] The emotion engine built into the device analyzes the user's facial expressions and voice in real time to obtain the user's emotional information. For example, if the user is feeling stressed, the emotion information extracted will be "feeling stressed." The obtained emotion information is also sent to the server.

[1072] Step 3:

[1073] The server generates a suggested menu based on the received ingredient information and emotion information. Specifically, it sets the ingredient information and emotion information as a prompt and sends a request to an external API equipped with a generative AI model. The server receives the optimal recipe as a response from the external API. For example, the prompt text could be "Please suggest a recipe using the following ingredients that matches the user's current emotion: {'tomato': '200g', 'chicken': '150g'} User emotion: 'I'm feeling stressed'."

[1074] Step 4:

[1075] The server receives a menu suggestion generated from an external API (e.g., "Relaxed salad with tomatoes and chicken") and sends it to the device. The device displays the menu suggestion to the user.

[1076] Step 5:

[1077] The user checks the suggested menu displayed on the device and selects the desired menu item. For example, they select "Relaxed Tomato and Chicken Salad." The selected menu item is notified to the server from the device.

[1078] Step 6:

[1079] The server updates the ingredient information based on the ingredient consumption amounts corresponding to the selected menu. For example, if "100g of tomatoes and 50g of chicken" are consumed, the server updates the ingredient information to "100g of tomatoes and 100g of chicken." The updated information is saved on the server and will be used the next time a suggested menu is generated.

[1080] Step 7:

[1081] Furthermore, the emotional information is updated based on the impact of the selected menu on the user's emotions. For example, the emotional state is updated to "refreshed." The emotion engine recognizes this data and sends it to the server. The new emotional information is also saved on the server and used for the next suggestion.

[1082] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

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

[1084] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[1085] [Fourth embodiment]

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

[1087] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

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

[1089] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

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

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

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

[1093] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1094] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

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

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

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

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

[1099] As an embodiment of the present invention, a specific implementation method of a system in which a user inputs ingredient information held by the user and generates and displays the most suitable suggested menu based on that information will be described.

[1100] User input of ingredient information

[1101] First, the user inputs the ingredients they have on hand using the device. The device collects the types and quantities of the ingredients and organizes them into a dictionary. For example, if the user inputs "onions, 200g" and "carrots, 100g", the device organizes this information as follows:

[1102] python

[1103] {

[1104] 'Onion': '200g',

[1105] 'Carrots': '100g'

[1106] }

[1107] Server-generated menu suggestions

[1108] Next, the device sends the collected ingredient information to the server. The server generates a suggested menu based on the received ingredient information. The server uses an external API to create a recipe from the ingredient information. At this time, the server sets the ingredient information as an API prompt and generates the optimal menu based on the API response.

[1109] Specifically, you can send a prompt like this to the API:

[1110] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[1111] Let's say the API returns a recipe for "onion and carrot soup."

[1112] Display of suggestion menu by device

[1113] The server generates a proposed menu and sends it to the terminal. The terminal displays the received proposed menu to the user. The user can check the proposed menu on the terminal.

[1114] User selects menu and updates ingredient information

[1115] The user selects the desired menu from the displayed suggested menu. For example, "onion and carrot soup" is selected. The device sends this selection information to the server. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[1116] Specifically, we update the ingredient information based on the selected menu, assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[1117] python

[1118] {

[1119] 'onion': '100g',

[1120] 'Carrots': '50g'

[1121] }

[1122] The updated ingredient information is stored on the server and used the next time a menu is proposed. In this way, a system is provided that can efficiently utilize the ingredient information stored by the user and reduce waste.

[1123] The above is a specific embodiment for carrying out the present invention.

[1124] The processing flow will be explained below.

[1125] Step 1:

[1126] The user inputs the information about ingredients they have on hand into the terminal. Specifically, the user inputs the information in the format of "ingredient name, quantity", and when all the information has been input, the user enters "end" to finish.

[1127] Step 2:

[1128] The terminal collects ingredient information entered by the user. The collected information is organized in dictionary format, with the key being the ingredient name and the value being the quantity.

[1129] Step 3:

[1130] The terminal sends the organized ingredient information to the server, which then sends the ingredient information from the terminal to the server via the network.

[1131] Step 4:

[1132] The server processes the ingredient information received from the terminal, and the received information is temporarily stored on the server.

[1133] Step 5:

[1134] The server generates a suggested menu based on the received ingredient information. To achieve this, the server calls an external recipe generation API and sets the ingredient information as a prompt.

[1135] Step 6:

[1136] The server receives a response from the API, which includes suggested menus and recipes.

[1137] Step 7:

[1138] The server sends the proposed menu to the terminal, and the generated proposed menu is sent to the terminal via the network.

[1139] Step 8:

[1140] The terminal receives the proposed menu and displays it to the user, who can then check the proposed menu on the terminal screen.

[1141] Step 9:

[1142] The user selects the desired menu from the proposed menu, and the selected menu is notified to the server by the terminal.

[1143] Step 10:

[1144] The server updates the ingredient information based on the user's selection, specifically by calculating and updating the ingredients and amounts used in the selected menu.

[1145] Step 11:

[1146] The server saves the updated ingredient information, which is then reused the next time a menu is generated.

[1147] The above is a detailed explanation of the processing steps in this system, and the specific operations at each step have been explained in an easy-to-understand manner.

[1148] Example 1

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

[1150] In today's world, reducing food waste and using it efficiently is an important issue. However, there are only a limited number of systems that allow users to manage information about ingredients on hand and suggest appropriate menus based on that information. Conventional methods often require users to manually manage ingredient information and spend time thinking up recipe ideas. Furthermore, there are few systems that automatically update ingredient information based on suggested menus, which can easily lead to food waste. There is a need to provide a system that solves these problems.

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

[1152] In this invention, the server includes means for a user to input ingredient information, means for the terminal to organize the input ingredient information into dictionary format, means for the terminal to send the organized ingredient information to the server, means for the server to generate a suggested menu by sending a prompt to an external API based on the ingredient information received, means for displaying the generated suggested menu to the user, means for updating the ingredient information based on the user's selection, and means for using the updated ingredient information to generate the next suggested menu. This allows users to efficiently manage their available ingredient information and easily obtain suggested menus that make the most of ingredients without waste.

[1153] "User" refers to an individual who uses this system to input and manage ingredient information and receive suggested menus.

[1154] "Terminal" refers to an electronic device that a user uses to input ingredient information and that displays suggested menus.

[1155] "Ingredient information" refers to data that indicates the types and amounts of ingredients that a user owns.

[1156] "Dictionary format" refers to a method of organizing data using key-value pairs, specifically a format in which the names of ingredients are the keys and the quantities are the values.

[1157] The term "server" refers to a computer processing device that receives ingredient information sent from a terminal, generates menu suggestions based on that information, and sends the results to the terminal.

[1158] "External API" refers to an external application programming interface that the Server utilizes to generate the suggestion menu.

[1159] "Prompt text" refers to the explanatory text used when making a specific request to an external API.

[1160] "Suggested menu" refers to suggestions for recipes and dishes that the user can cook based on the input ingredient information.

[1161] "Update" refers to the act of updating ingredient information to the latest version based on the user's selection.

[1162] "Next time" refers to a future operation or use that follows the current operation.

[1163] The embodiments of the present invention will be specifically described below.

[1164] First, the user inputs ingredient information using their own device. The device collects the input ingredient information and organizes it in dictionary format. For example, if the user inputs "200g of onions" and "100g of carrots," the device converts this information into dictionary format and creates data organized as follows:

[1165] python

[1166] {

[1167] 'Onion': '200g',

[1168] 'Carrots': '100g'

[1169] }

[1170] Next, the device sends the organized ingredient information to the server. This is generally done using an HTTP request. The server uses an external API to generate menu suggestions based on the received ingredient information. The server sets the ingredient information as a prompt and sends a request to the external API. For example, the following prompt is sent to the external API:

[1171] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[1172] The external API receives this prompt, creates a menu of suggestions based on that information, and returns a response to the server, such as a recipe for "onion and carrot soup."

[1173] The server analyzes the returned recipe information, generates a suggested menu that is optimal for the user, and sends it to the terminal. The terminal displays the suggested menu received from the server to the user. The user can check the suggested menu on the terminal and select the desired menu.

[1174] Furthermore, when the user selects the desired menu item, the device sends the selection information to the server. The server then updates the ingredient information based on the selected menu item. For example, the ingredient information is updated assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[1175] python

[1176] {

[1177] 'onion': '100g',

[1178] 'Carrots': '50g'

[1179] }

[1180] The updated ingredient information is stored on the server and will be used the next time a menu is proposed.

[1181] This system allows users to efficiently manage information about ingredients on hand and easily obtain suggested menus that utilize ingredients without waste, thereby reducing food waste and providing a system that makes users' lives more convenient.

[1182] The above is a specific embodiment for carrying out the present invention.

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

[1184] Step 1:

[1185] The user uses the terminal to input information about ingredients they have on hand. For example, the user enters "200g of onions" and "100g of carrots" into the terminal's input form. This input information is the data that will be used as the basis for the next processing step.

[1186] Step 2:

[1187] The terminal collects the entered ingredient information and organizes it in dictionary format. For example, "200g of onions" and "100g of carrots" are converted into dictionary format as key-value pairs. Specifically, the data obtained from the form is converted into dictionary format within the program.

[1188] Step 3:

[1189] The device sends the organized ingredient information to the server. An HTTP request is used for transmission, and the ingredient information is sent in JSON format. At this time, the input dictionary-format data is sent to the server, allowing it to be processed on the server side.

[1190] Step 4:

[1191] The server generates a suggested menu based on the received ingredient information. To do this, the server uses an external API. Specifically, the server converts the ingredient information into a prompt and sends a request to the external API. In response to this request, the API returns the corresponding recipe information.

[1192] Step 5:

[1193] When creating the prompt, the server converts the data into a format such as:

[1194] "Suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'}"

[1195] By sending this prompt to the API, the appropriate recipe will be returned as a response.

[1196] Step 6:

[1197] The external API generates a recipe based on the received prompt and returns it to the server. For example, a recipe such as "onion and carrot soup" is returned. This information is received and analyzed on the server side.

[1198] Step 7:

[1199] The server analyzes the returned recipe information and generates a menu of suggestions, which are formatted in a way that is meaningful to the user and ready to be sent to the user in the next processing step.

[1200] Step 8:

[1201] The server sends the generated suggested menu to the terminal, and the terminal displays the received suggested menu to the user, who can then check the suggested menu on the terminal.

[1202] Step 9:

[1203] The user selects the desired menu from the displayed menu of suggestions, for example, "onion and carrot soup." This selection information is the basis for the next processing step.

[1204] Step 10:

[1205] The terminal transmits the user's selection information to the server. The transmission of the selected menu information to the server starts the processing in the next step.

[1206] Step 11:

[1207] The server updates the ingredient information based on the selected menu. Specifically, it updates the ingredient information it holds, assuming that "100g of onions" and "50g of carrots" have been consumed based on the selected menu. After the update, the ingredient information is kept up to date.

[1208] Step 12:

[1209] The updated ingredient information is stored on the server and used the next time a menu is proposed. This ensures that the ingredient information held by the user is always up-to-date, reducing waste.

[1210] The above is the flow of specific processing steps of this system.

[1211] (Application example 1)

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

[1213] In modern food manufacturing factories, reducing material waste and optimizing production plans are serious challenges. It is particularly difficult to efficiently manage the large amounts of materials used within the factory and consistently provide optimal production plans. This can lead to overpurchasing and waste of materials, which can increase manufacturing costs and reduce production efficiency. To solve these issues, a system is needed that can accurately grasp material information within the factory and automatically generate and provide optimal production plans based on that information.

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

[1215] In this invention, the server includes a means for a user to input ingredient information, a means for generating a proposed plan based on the ingredient information received by the server, and a means for displaying the generated proposed plan to the user. This allows factory robots to collect ingredient information and transmit the data to the cloud server, enabling production planning. Furthermore, by providing a means for updating ingredient information based on user selections, it is possible to reduce ingredient waste and consistently provide efficient production plans.

[1216] "Ingredient information" is data regarding the type and amount of food entered by the user.

[1217] "Proposed plan" refers to the optimal menu and production plan generated based on the input ingredient information.

[1218] "User" refers to the person who uses the system to input ingredient information and check and select the proposed plan, or the entity that operates the system.

[1219] "Server" refers to a computing device that receives ingredient information and generates and provides proposed plans.

[1220] A "factory robot" refers to an automated mechanical device that collects material information within a factory.

[1221] A "cloud server" is a remote server connected via the Internet that processes and stores data.

[1222] "Data transmission" refers to the process by which factory robots send collected material information to a cloud server.

[1223] "Manufacturing planning" refers to determining the optimal manufacturing process and work plan based on collected material information.

[1224] "Update" refers to the process of updating ingredient information to the latest version based on the user's selection.

[1225] As an embodiment of the present invention, a system will be described that utilizes factory robots in a food manufacturing factory to efficiently perform operations from collecting ingredient information to proposing a manufacturing plan and updating food ingredient information.

[1226] First, the factory robot collects information about the ingredients used in the factory. Specifically, it obtains the type and quantity of ingredients from sensors installed on the ingredient shelves and organizes them as food types and their quantities. For example, if there is 500g of flour and 200g of sugar, this information is collected in dictionary format.

[1227] Next, the device sends the collected material information to the cloud server. Based on the received material information, the cloud server uses a generative AI model to propose an optimal manufacturing plan. To use the generative AI model, the cloud server calls an external API and sets the material information as a prompt. Specifically, it sends the following prompt:

[1228] "Please propose a recipe using the following ingredients: 500g flour, 200g sugar, 100g butter."

[1229] The cloud server then receives the optimal manufacturing plan returned by the API and sends it to the device. The user can then review the proposed manufacturing plans on their device and select the one they prefer. The selected plan is then sent back to the cloud server, which calculates the amount of material consumed based on the selected plan and updates the material information.

[1230] For example, if a user selects a production plan that uses 200g of flour and 100g of sugar, the cloud server recalculates the new ingredient information, updating the flour to 300g and sugar to 100g. This updated information is used for the next menu generation.

[1231] This system enables food manufacturing factories to significantly reduce material waste and consistently provide efficient and optimal production plans. The specific hardware used includes sensors installed on material shelves, factory robots, and smartphones or tablets as terminals, while the cloud server requires an internet connection. The software used is Raspberry Pi or Arduino for sensor data collection, and Amazon Web Services or Google Cloud Platform for the cloud server.

[1232] This will enable consistent material management and optimal production plans across the entire system, which is expected to significantly improve production efficiency in food manufacturing factories.

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

[1234] Step 1:

[1235] Factory robots collect material information.

[1236] Input: Data from sensors installed on material shelves.

[1237] Data processing: The data obtained from the sensors is organized into material types and quantities and converted into dictionary format.

[1238] Output: Collected ingredient information (e.g. "500g flour, 200g sugar").

[1239] Step 2:

[1240] The terminal sends material information to the cloud server.

[1241] Input: Material information collected and organized by factory robots.

[1242] Data processing: Material information is converted into JSON format and sent to the cloud server.

[1243] Output: Material information sent to the cloud server.

[1244] Step 3:

[1245] Based on the material information received by the server, a generative AI model is used to generate a proposed plan.

[1246] Input: Material information received by the cloud server.

[1247] Data processing: Send material information as prompts to an external API and use a generative AI model to obtain the optimal manufacturing plan.

[1248] Output: The generated production plan (e.g. "Production plan using 200g flour and 100g sugar").

[1249] Step 4:

[1250] The server transmits the generated manufacturing plan to the terminal, which displays it to the user.

[1251] Input: Generated manufacturing plan.

[1252] Data processing: The generated manufacturing plan is formatted into a form that is easy for users to understand.

[1253] Output: Manufacturing plan that the user sees on the terminal.

[1254] Step 5:

[1255] The user selects the desired manufacturing plan.

[1256] Input: Manufacturing plan displayed on the terminal.

[1257] Data processing: The user selects the manufacturing plan they deem most optimal and sends the selected information to the cloud server.

[1258] Output: The selected manufacturing plan.

[1259] Step 6:

[1260] The server updates the material information based on the selected manufacturing plan.

[1261] Input: The manufacturing plan selected by the user.

[1262] Data processing: Updates current material information based on the material consumption amount listed in the selected manufacturing plan.

[1263] Output: Updated ingredient information (e.g. "300g flour, 100g sugar").

[1264] These are the processing steps of the system program that realizes this application example. This automates material management and optimization of manufacturing plans within the factory, enabling efficient operation.

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

[1266] As an embodiment of the present invention, a specific implementation method of a system that inputs ingredients information of a user combined with an emotion engine and generates and displays suggested menus based on that information will be described.

[1267] User input of ingredient information

[1268] First, the user uses the device to input information about ingredients they have on hand. The device collects the types and quantities of the ingredients and organizes them into a dictionary. For example, if the user inputs "onions, 200g" and "carrots, 100g," the device organizes this information as follows:

[1269] python

[1270] {

[1271] 'Onion': '200g',

[1272] 'Carrots': '100g'

[1273] }

[1274] Acquiring user emotion information

[1275] The device is equipped with an emotion engine that recognizes the user's emotions in real time from their facial expressions and voice. This emotional information is taken into consideration when suggesting menu items.

[1276] Server-generated menu suggestions

[1277] Next, the device sends the collected ingredient information and the user's emotional information to the server. The server generates a suggested menu based on the received ingredient information and emotional information. The server uses an external API to create a recipe from this information. At this time, the server sets the ingredient information and emotional information as API prompts.

[1278] For example, set the prompt as follows:

[1279] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[1280] Let's say the API responds with a recipe for "Comforting Onion and Carrot Soup."

[1281] Display of suggestion menu by device

[1282] The server generates a suggested menu and sends it to the terminal. The terminal displays the received suggested menu to the user. The user can check the suggested menu on the terminal screen.

[1283] User selects menu and updates ingredient information

[1284] The user selects the desired menu from the displayed suggested menu. For example, suppose "onion and carrot soup" is selected. The selected menu is notified to the server by the terminal. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[1285] Specifically, we update the ingredient information based on the selected menu, assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the updated data will look like this:

[1286] python

[1287] {

[1288] 'onion': '100g',

[1289] 'Carrots': '50g'

[1290] }

[1291] Update user emotion information

[1292] Furthermore, the emotion information is also updated based on the menu selected by the user. For example, if a specific menu is determined to have the effect of refreshing the user's mood, the emotion engine will update the user's emotion as "refreshed."

[1293] The updated ingredient information and emotion information are stored on the server and used the next time a menu is proposed. In this way, the system efficiently utilizes the ingredient information stored by the user, reduces waste, and responds to changes in the user's emotions.

[1294] The above is a specific embodiment for carrying out the present invention.

[1295] The processing flow will be explained below.

[1296] Step 1:

[1297] The user inputs information about ingredients they have on hand into the terminal. The user inputs the information in the format of "ingredient name, quantity", and when they have finished inputting all the information, they input "end" to complete the input.

[1298] Step 2:

[1299] The terminal collects ingredient information entered by the user. The collected information is organized in dictionary format, with the key being the ingredient name and the value being the quantity.

[1300] Step 3:

[1301] The device uses an emotion engine to collect the user's emotional information, evaluating the user's emotions in real time through facial expressions and voice analysis, and collecting this emotional information as independent data.

[1302] Step 4:

[1303] The terminal transmits the organized ingredient information and collected emotion information to the server, which then transmits the ingredient information and emotion information to the server via a network.

[1304] Step 5:

[1305] The server processes the ingredient information and emotion information received from the device. The received information is temporarily stored on the server.

[1306] Step 6:

[1307] The server generates a suggested menu based on the ingredient information and emotion information. The server calls an external recipe generation API and sets the ingredient information and emotion information as a prompt. For example, the prompt could be set as follows: "Please suggest a recipe using the following ingredients that matches the current user's emotion: {'onion': '200g', 'carrot': '100g'} User emotion: 'Feeling tired'."

[1308] Step 7:

[1309] The server receives the response from the API and retrieves the suggested menu. For example, if the API returns a recipe for "Relaxing Onion and Carrot Soup," the server retrieves this menu information.

[1310] Step 8:

[1311] The server sends the acquired proposal menu to the terminal, and the generated proposal menu is sent to the terminal via the network.

[1312] Step 9:

[1313] The terminal receives the proposed menu and displays it to the user, who can then check the proposed menu on the terminal screen.

[1314] Step 10:

[1315] The user selects the desired menu from the displayed suggested menu. For example, the user selects "onion and carrot soup." The selected menu is notified to the server by the terminal.

[1316] Step 11:

[1317] The server updates the ingredient information based on the user's selection. It calculates the ingredients used in the selected menu and their amounts, and updates the ingredient information assuming that, for example, 100g of onions and 50g of carrots were consumed. In this case, the updated data will look like this:

[1318] python

[1319] {

[1320] 'onion': '100g',

[1321] 'Carrots': '50g'

[1322] }

[1323] Step 12:

[1324] The server saves the updated ingredient information, which is then reused the next time a menu is generated.

[1325] Step 13:

[1326] The emotion engine updates the emotion information based on the user's selection. For example, if a particular menu item is determined to have a refreshing effect on the user's mood, the emotion engine updates the user's emotion as "refreshed."

[1327] Step 14:

[1328] The server stores the updated emotion information, so that the next time a menu suggestion is generated, the user's latest emotion state can be taken into account.

[1329] The above are the specific steps for carrying out the present invention, and the specific operations at each step have been explained in detail.

[1330] Example 2

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

[1332] Conventional ingredient management and recipe suggestion systems mainly display suggested menus based on ingredient information entered by the user, but have the problem of not being able to take into account individual states such as the user's emotions. Furthermore, while it is expected that more personalized suggestions will be possible by utilizing the user's emotional information when generating suggested menus, there has been a lack of means to achieve this.

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

[1334] In this invention, the server includes a means for a user to input ingredient information, a means for the terminal to organize the input ingredient information into dictionary format, a means for the terminal to acquire user emotional information, a means for the server to receive the emotional information and ingredient information, a means for the server to generate a suggested menu based on the ingredient information and emotional information received, a means for the terminal to display the generated suggested menu to the user, and a means for updating the ingredient information and emotional information based on the user's selection. This makes it possible to provide a more personalized suggested menu that takes into account the user's emotional information, which is expected to improve user satisfaction.

[1335] A "user" is an entity that uses this system to input ingredient information and emotional information and use the suggested menu.

[1336] A "terminal" is a device that a user accesses to input ingredient information, acquire emotional information, and display suggested menus.

[1337] The "server" is a central processing unit that generates menu suggestions based on the ingredient information and emotion information sent from the terminal.

[1338] An "emotion engine" is software or hardware that analyzes emotions from a user's facial expressions and voice in real time and acquires appropriate emotional information.

[1339] "Ingredient information" is data relating to the types and amounts of ingredients that the user owns.

[1340] A "suggested menu" is a cooking recipe that the server generates based on ingredient information and emotion information and presents to the user.

[1341] "External API" means an external application programming interface that the server uses to generate the suggestion menu.

[1342] The "dictionary format" is a data format that organizes ingredient information as key-value pairs and manages them efficiently.

[1343] "Update" is an operation for keeping ingredient information and emotion information up to date according to user selection.

[1344] "Real-time" is a time frame that means data is acquired and processed immediately.

[1345] As an embodiment of the present invention, a specific implementation method of a system that inputs ingredients information of a user combined with an emotion engine and generates and displays suggested menus based on that information will be described.

[1346] User input of ingredient information

[1347] First, the user uses the terminal to input information about ingredients they have on hand. The terminal collects the types and quantities of the ingredients entered and organizes them in dictionary format. For example, if the user enters "onions, 200g" and "carrots, 100g," the terminal organizes this information. Dictionary format is a data format that organizes ingredient information as key-value pairs and manages them efficiently. The terminal is designed to make it easy for users to input information using a GUI (Graphical User Interface).

[1348] Acquiring user emotion information

[1349] Next, the device is equipped with an emotion engine that recognizes emotions in real time from the user's facial expressions and voice. This emotional information is taken into consideration when suggesting recipes. The emotion engine acquires data, for example, through a camera or microphone, and analyzes it in real time. Examples of software used include OpenCV and DeepFace.

[1350] Server-generated menu suggestions

[1351] The device sends the collected ingredient information and the user's emotional information to the server. The server generates a suggested menu based on the received information. The server uses an external API to generate a recipe from this information. At this time, the server sets the ingredient information and emotional information as the API prompt. The prompt text is set as follows:

[1352] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[1353] Thus, the API might respond with a recipe for "Comforting Onion and Carrot Soup."

[1354] Display of suggestion menu by device

[1355] The server sends the generated suggested menu to the terminal. The terminal displays the received suggested menu to the user. The user can check the suggested menu on the terminal screen. The screen displays the recipe name, ingredients, steps, etc., allowing the user to intuitively select a menu.

[1356] User selects menu and updates ingredient information

[1357] The user selects the desired menu from the displayed suggested menu. For example, suppose "onion and carrot soup" is selected. The selected menu is notified to the server by the terminal. The server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount. For example, the ingredient information is updated assuming that "100g of onions" and "50g of carrots" have been consumed. In this case, the ingredient information is updated according to the selected menu.

[1358] Update user emotion information

[1359] Furthermore, the emotion information is also updated based on the menu selected by the user. For example, if a specific menu is determined to have the effect of refreshing the user's mood, the emotion engine updates the user's emotion to "refreshed." This updated emotion information is used when generating the next suggested menu.

[1360] In this way, a system is provided that efficiently utilizes the food ingredient information held by the user, reduces waste, and also responds to changes in the user's emotions.

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

[1362] Step 1: User enters ingredient information

[1363] The user launches the device app and inputs information about ingredients they have on hand through text boxes and drop-down lists. For example, they might input information like "onions, 200g" or "carrots, 100g." The device receives this information and converts it into a dictionary format. The dictionary format manages pairs of ingredient names as keys and quantities as values. For example, it can be formatted as follows:

[1364] python

[1365] {

[1366] 'Onion': '200g',

[1367] 'Carrots': '100g'

[1368] }

[1369] Input: Ingredient information entered by the user

[1370] Output: Ingredient information organized in dictionary format

[1371] Step 2: Obtaining user emotion information

[1372] The device's built-in emotion engine analyzes the user's facial expressions and voice in real time through the camera and microphone, using software libraries such as OpenCV and DeepFace. The analyzed emotion data is then classified as "tired" or "confused," for example.

[1373] Input: User facial and voice data acquired from camera and microphone

[1374] Output: Parsed emotion information

[1375] Step 3: Server generates suggestion menu

[1376] The device sends the organized ingredient information and analyzed emotion information to the server. The server receives them and generates a prompt. This prompt is set as a request to the external API. For example, the prompt is generated as follows:

[1377] "Please suggest a recipe using the following ingredients: {'onion': '200g', 'carrot': '100g'} based on the user's current emotion: 'Feeling tired'"

[1378] The server sends this prompt to an external recipe API, which generates an appropriate recipe and returns it to the server.

[1379] Input: Ingredient information and emotional information sent from the device

[1380] Output: Suggestion menu returned from external API

[1381] Step 4: Display the suggestion menu by device

[1382] The server sends the suggested menu received from the external API to the device. The device receives this information and displays it to the user. The screen displays the recipe name, ingredients, steps, etc. For example, it displays a recipe for "Relaxing Onion and Carrot Soup."

[1383] Input: Suggestion menu sent from the server

[1384] Output: The suggestion menu displayed to the user

[1385] Step 5: User selects menu and updates ingredients

[1386] The user selects the desired menu from the suggested menu. Once the selection is made, the device notifies the server of the selection. The server updates the ingredient information based on the selected menu. For example, let's assume that "100g of onions" and "50g of carrots" are used. The updated ingredient information will be as follows:

[1387] python

[1388] {

[1389] 'onion': '100g',

[1390] 'Carrots': '50g'

[1391] }

[1392] Input: Menu information selected by the user

[1393] Output: Updated ingredient information

[1394] Step 6: Update user's emotion information

[1395] The emotion engine is then run again to evaluate the impact of the selected menu on the user's emotions. For example, if the selected menu is determined to be "refreshed," the new emotion information is notified to the server and updated. This ensures that the latest emotion information is taken into account when suggesting a menu next time.

[1396] Input: User menu choices and their impact

[1397] Output: Updated emotion information

[1398] These processing steps realize a system that provides personalized menu suggestions based on the user's ingredient information and emotional information.

[1399] (Application example 2)

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

[1401] Conventional menu suggestion generation systems are unable to take the user's emotions into account, making it impossible to suggest appropriate menus that reflect the user's mental state at any given time. Furthermore, managing the user's ingredient information is cumbersome, making it difficult to suggest efficient menus. There is a need for a system that can overcome these drawbacks and make efficient menu suggestions while taking the user's emotional information into account.

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

[1403] In this invention, the server includes a means for a user to input ingredient information, a means for generating a suggested menu based on the ingredient information and emotion information received by the server, a means for displaying the generated suggested menu to the user, a means for updating the ingredient information based on the user's selection, and a means for acquiring the user's emotion information using an emotion engine built into the terminal. This makes it possible to propose an optimal menu based on the user's emotion information and efficiently manage ingredient information.

[1404] "Ingredient information" is information that indicates the types and amounts of ingredients that the user has on hand.

[1405] A "suggested menu" refers to a recipe or menu of food that is generated by the server based on the ingredient information and emotion information entered by the user.

[1406] "Emotion information" is information about the user's mental state that the emotion engine obtains in real time from the user's facial expressions and voice.

[1407] An "emotion engine" is an engine that analyzes the user's facial expressions and voice to recognize and acquire their emotions in real time.

[1408] An "external API" is an external application programming interface for generating a suggestion menu based on a request from a server.

[1409] A "terminal" is a device (such as a smartphone or tablet) that allows a user to input ingredient information, acquire emotion information, and display suggested menus.

[1410] In this embodiment, a system is used in which a server, a terminal, and a user each play their respective roles. Here, we will explain in detail the process of inputting information about ingredients and emotions from the user, and generating and displaying the optimal menu suggestions based on that information.

[1411] First, the user uses a device (such as a smartphone or tablet) to input information about ingredients they have on hand. The device collects the types and quantities of the ingredients entered and organizes them in dictionary format. For example, if a user enters "tomatoes, 200g" and "chicken, 150g," the device organizes this information and sends it to the server. The server receives and analyzes this information.

[1412] Next, the device is equipped with an emotion engine that recognizes emotional information in real time from the user's facial expressions, voice, etc. This emotional information is also sent to the server and analyzed together with the ingredient information.

[1413] The server generates a suggested menu based on the received ingredient information and emotion information. The server uses an external API to generate the optimal recipe from this information. In this case, the server sets the ingredient information and emotion information as a prompt. Specifically, the server uses the following prompt text:

[1414] "Suggest a recipe using the following ingredients and matching the user's current emotion: {'tomato': '200g', 'chicken': '150g'} User emotion: 'stressed'"

[1415] Based on this prompt, the generative AI model responds with a suggested menu item (e.g., "Relaxed salad with tomatoes and chicken").

[1416] The generated suggested menu is sent from the server to the terminal, which displays it to the user. The user checks the suggested menu on the terminal screen and selects the desired menu. The selected menu is notified to the server by the terminal, and the server updates the ingredient information based on the selected menu and the corresponding ingredient consumption amount.

[1417] For example, if a user selects "Relaxed Tomato and Chicken Salad" and the menu requires "100g of tomatoes and 50g of chicken," the server updates the ingredient information and stores "100g of tomatoes and 100g of chicken" as new data.

[1418] Furthermore, the emotion information is also updated based on the selected menu. If a particular menu is determined to have an effect of improving the user's mood, the emotion engine updates the user's emotion information as "refreshed."

[1419] In this way, it is possible to provide a system that efficiently utilizes the ingredient information held by the user, reduces waste, and also responds to changes in the user's emotions.

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

[1421] Step 1:

[1422] The user uses the terminal to input information about ingredients they have on hand. The type and amount of the ingredients entered become input data, and the terminal organizes this into a dictionary format. For example, inputs such as "tomato, 200g" and "chicken, 150g" are organized as "{'tomato': '200g', 'chicken': '150g'}". The organized data is then sent directly to the server.

[1423] Step 2:

[1424] The emotion engine built into the device analyzes the user's facial expressions and voice in real time to obtain the user's emotional information. For example, if the user is feeling stressed, the emotion information extracted will be "feeling stressed." The obtained emotion information is also sent to the server.

[1425] Step 3:

[1426] The server generates a suggested menu based on the received ingredient information and emotion information. Specifically, it sets the ingredient information and emotion information as a prompt and sends a request to an external API equipped with a generative AI model. The server receives the optimal recipe as a response from the external API. For example, the prompt text could be "Please suggest a recipe using the following ingredients that matches the user's current emotion: {'tomato': '200g', 'chicken': '150g'} User emotion: 'I'm feeling stressed'."

[1427] Step 4:

[1428] The server receives a menu suggestion generated from an external API (e.g., "Relaxed salad with tomatoes and chicken") and sends it to the device. The device displays the menu suggestion to the user.

[1429] Step 5:

[1430] The user checks the suggested menu displayed on the device and selects the desired menu item. For example, they select "Relaxed Tomato and Chicken Salad." The selected menu item is notified to the server from the device.

[1431] Step 6:

[1432] The server updates the ingredient information based on the ingredient consumption amounts corresponding to the selected menu. For example, if "100g of tomatoes and 50g of chicken" are consumed, the server updates the ingredient information to "100g of tomatoes and 100g of chicken." The updated information is saved on the server and will be used the next time a suggested menu is generated.

[1433] Step 7:

[1434] Furthermore, the emotional information is updated based on the impact of the selected menu on the user's emotions. For example, the emotional state is updated to "refreshed." The emotion engine recognizes this data and sends it to the server. The new emotional information is also saved on the server and used for the next suggestion.

[1435] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

[1437] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1438] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1439] FIG. 9 illustrates an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and behaviors arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1440] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1441] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1442] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1443] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1444] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1445] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1446] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1447] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

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

[1449] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1450] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1451] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1452] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1453] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1454] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1455] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1456] The following is further disclosed regarding the above embodiment.

[1457] (Claim 1)

[1458] A means for a user to input ingredient information;

[1459] A means for generating a menu suggestion based on the ingredient information received by the server;

[1460] means for displaying the generated suggestion menu to a user;

[1461] means for updating ingredient information based on user selection;

[1462] A system including:

[1463] (Claim 2)

[1464] 10. The system of claim 1, utilizing an external API to generate the suggestion menu.

[1465] (Claim 3)

[1466] 2. The system according to claim 1, further comprising means for collecting ingredient information input by a user in dictionary format.

[1467] "Example 1"

[1468] (Claim 1)

[1469] A means for a user to input ingredient information;

[1470] A means for organizing the input food ingredient information into a dictionary format by the terminal;

[1471] A means for transmitting the food ingredient information organized by the terminal to a server;

[1472] A means for generating a suggested menu by sending a prompt to an external API based on the ingredient information received by the server;

[1473] means for displaying the generated suggestion menu to a user;

[1474] means for updating ingredient information based on user selection;

[1475] A means for using the updated food information to generate the next menu proposal;

[1476] A system including:

[1477] (Claim 2)

[1478] 10. The system of claim 1, utilizing an external API to generate the suggestion menu.

[1479] (Claim 3)

[1480] 2. The system according to claim 1, further comprising means for collecting ingredient information input by a user in dictionary format.

[1481] "Application Example 1"

[1482] (Claim 1)

[1483] A means for a user to input ingredient information;

[1484] A means for generating a proposed plan based on the ingredient information received by the server;

[1485] means for displaying the generated proposed plan to a user;

[1486] means for updating ingredient information based on user selection;

[1487] A means for the factory robot to collect material information;

[1488] A means for transmitting data to a cloud server and performing manufacturing planning;

[1489] A system including:

[1490] (Claim 2)

[1491] 10. The system of claim 1, utilizing an external API to generate the proposed plan.

[1492] (Claim 3)

[1493] 2. The system according to claim 1, further comprising means for collecting material information input by a user in the form of a dictionary.

[1494] "Example 2: Combining Emotion Engines"

[1495] (Claim 1)

[1496] A means for a user to input ingredient information;

[1497] A means for organizing the input food ingredient information into a dictionary format by the terminal;

[1498] A means for the terminal to acquire emotion information of a user;

[1499] A means for the server to receive emotion information and ingredient information;

[1500] a means for generating a menu suggestion based on the ingredient information and emotion information received by the server;

[1501] means for displaying the generated suggestion menu to the user by the terminal;

[1502] means for updating ingredient information and emotion information based on user selection;

[1503] A system including:

[1504] (Claim 2)

[1505] 10. The system of claim 1, utilizing an external API to generate the suggestion menu.

[1506] (Claim 3)

[1507] 10. The system of claim 1, further comprising an emotion engine that obtains emotion information in real time.

[1508] "Application example 2 when combining emotion engines"

[1509] (Claim 1)

[1510] A means for a user to input ingredient information;

[1511] A means for generating a menu suggestion based on the ingredient information and emotion information received by the server;

[1512] means for displaying the generated suggestion menu to a user;

[1513] means for updating ingredient information based on user selection;

[1514] A means for acquiring user emotion information using an emotion engine built into the terminal;

[1515] A system including:

[1516] (Claim 2)

[1517] 10. The system of claim 1, utilizing an external API to generate the suggestion menu.

[1518] (Claim 3)

[1519] 2. The system according to claim 1, further comprising means for collecting ingredient information input by a user in dictionary format. [Explanation of symbols]

[1520] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for a user to input ingredient information; A means for generating a menu suggestion based on the ingredient information received by the server; means for displaying the generated suggestion menu to a user; means for updating ingredient information based on user selection; A system including:

2. The system of claim 1 , which utilizes an external API to generate the suggestion menu.

3. 2. The system according to claim 1, further comprising means for collecting ingredient information input by a user in dictionary form.

Images