System

Abstract

To provide a system.SOLUTION: A system includes means for recognizing the emotions of a user using an emotion engine based on input information of the user, and means for generating a menu and a recipe using a generative AI model based on prompt sentences that combines the recognized emotions and at least one of school lunch rules, a budget, and nutritional balance in the input information.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 a description and related instruction sentence regarding 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] JP 2022-180282 A Summary of the Invention [Problem to be solved by the invention]

[0004] The organizations that receive group meals are diverse, including company cafeterias, schools, elderly care facilities, and hospitals, but creating a menu requires specialized knowledge, which is time-consuming and costly. In particular, creating a menu that takes nutritional balance into account requires specialized knowledge, which is a major challenge for meal service providers. [Means for solving the problem]

[0005] We provide a system that uses generation AI to automatically generate menus for a specified period. Menus and recipes are generated after specifying the default school lunch rules, budget, nutritional balance, etc., and are output in an easy-to-understand manner on an application linked to the API. This enables school lunch operators to replace nutritionists with AI, reducing the time and cost required to create menus. [Brief description of the drawings]

[0006] [Figure 1] 1 is a conceptual diagram showing an example of the configuration of a data processing system according to a first embodiment. [Diagram 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. FIG. [Diagram 3] FIG. 11 is a conceptual diagram showing an example of the configuration of a data processing system according to a second embodiment. [Figure 4] FIG. 11 is a conceptual diagram showing an example of main functions of a data processing device and smart glasses according to a second embodiment. [Diagram 5] FIG. 13 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. 13 is a conceptual diagram showing an example of the configuration of a data processing system according to a fourth embodiment. [Figure 8] FIG. 13 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. 2 is a sequence diagram showing a process flow of the data processing system in the first embodiment of the first form example. [Figure 12] FIG. 11 is a sequence diagram showing a process flow of the data processing system in the application example 1 of the first embodiment. [Figure 13] FIG. 11 is a sequence diagram showing a process flow of the data processing system in the second embodiment of the second embodiment. [Figure 14] FIG. 13 is a sequence diagram showing a process flow of the data processing system in application example 2 of embodiment 2. [Figure 15]FIG. 13 is a sequence diagram showing a process flow of a data processing system in a third embodiment of the present invention. [Figure 16] FIG. 13 is a sequence diagram showing a process flow of the data processing system in the third application example of the third embodiment. [Figure 17] FIG. 13 is a sequence diagram showing the flow of processing in the data processing system in the first embodiment of the first form example when an emotion engine is combined. [Figure 18] FIG. 13 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1 of Form Example 1 when combined with an emotion engine. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

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

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

[0009] In the following embodiments, a signed processor (hereinafter simply referred to as a "processor") may be one arithmetic device or a combination of multiple arithmetic devices. Furthermore, a processor may be one 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), an APU (Accelerated Processing Unit), or a TPU (TENSOR PROCESSING UNIT (registered trademark)).

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

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

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

[0013] 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. In addition, in this specification, the same idea as "A and / or B" is also applied when three or more things are expressed by connecting them with "and / or."

[0014] [First embodiment]

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

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

[0017] 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 wide area network (WAN) and / or a local area network (LAN).

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

[0019] The reception device 38 includes a touch panel 38A and a microphone 38B, and receives user input. The touch panel 38A detects contact with a pointer (e.g., a pen or a finger) to receive user input by the touch of the pointer. 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.

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

[0021] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for transmitting and receiving various types of information between the processor 46 and the processor 28 via the network 54.

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

[0023] As shown in Fig. 2, 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. The specific process program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific process program 56 from the storage 32, and executes the read specific process 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 process program 56 executed on the RAM 30.

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

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

[0026] Next, the specific processing by the specific processing unit 290 of the data processing device 12 will be described.

[0027] "Example 1"

[0028] One embodiment of the present invention is a system that uses generation AI to automatically generate menus for a specified period. This system generates menus and recipes based on preset school lunch rules, budgets, nutritional balance, etc. The generated menus and recipes are output by an application linked to the API, and school lunch operators can use this to replace nutritionists with AI.

[0029] "Example 2"

[0030] As a specific example, consider the case where a school lunch provider uses this system. First, the school lunch provider specifies the school lunch rules (e.g., serving fish once a week), budget, and nutritional balance (e.g., calories per meal and the ratio of protein, fat, and carbohydrates) to the generation AI. Based on this information, the generation AI automatically generates menus and recipes for the specified period. The generated menus and recipes are output by an application linked to the API, and the school lunch provider can check them and make adjustments as necessary.

[0031] The process flow of each embodiment will be described below.

[0032] "Example 1"

[0033] Step 1: The school lunch provider specifies the default school lunch rules, budget, nutritional balance, etc. to the generation AI.

[0034] Step 2: The generation AI automatically generates menus and recipes for the specified period based on the specified information.

[0035] Step 3: The generated menu and recipes are output to the application that is linked to the API.

[0036] Step 4: The food service provider reviews the printed menu and recipes and makes adjustments as necessary.

[0037] "Example 2"

[0038] Step 1: The school lunch provider specifies the lunch rules (e.g., serving fish once a week), budget, and nutritional balance (e.g., calories per meal, and the ratio of protein, fat, and carbohydrates) to the generation AI.

[0039] Step 2: Based on this information, the generation AI automatically generates menus and recipes for the specified period.

[0040] Step 3: The generated menu and recipes are output to the application that is linked to the API.

[0041] Step 4: The food service provider reviews the printed menu and recipes and makes adjustments as necessary.

[0042] Example 1

[0043] Next, a description will be given of Example 1 of the embodiment 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".

[0044] Traditionally, school lunch menus were created manually by nutritionists, which took time and effort, and it was difficult to consider budgets and nutritional balance. In addition, specialized knowledge of nutritionists was required, and it is often difficult for school lunch operators to secure human resources. This has created a demand for efficient and effective menu creation.

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

[0046] In this invention, the server includes a means for the user to input conditions, a means for the server to receive the conditions, a means for the server to send a prompt to the generation AI model, a means for the generation AI model to generate a menu, a means for the server to send the generated menu to an API partner, and a means for the terminal to display the results. This allows the user to easily specify conditions and efficiently generate a menu.

[0047] The "means for the user to input conditions" is an interface that allows the user to input conditions such as school lunch rules, budget, and nutritional balance.

[0048] The "means for the server to receive the conditions" is a function that enables the server to receive and analyze the conditions sent from the user.

[0049] "Means for the server to send a prompt to the generative AI model" refers to a function for generating a prompt sentence based on the conditions received by the server and sending it to the generative AI model.

[0050] "Means for the generative AI model to generate a menu" refers to the function by which the generative AI model automatically creates a menu that meets the specified conditions based on the prompt text sent to it.

[0051] "Means for the server to send the generated menu to the API partner" refers to a function that enables the server to send the menu received from the generative AI model to the partner application via API.

[0052] "Means for the terminal to display the results" refers to a function for displaying the menu received from the API-connected application on the user's terminal.

[0053] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0054] This invention is a system that uses a generative AI model to automatically generate a menu for a specified period. This system generates the menu and recipes based on the user's input of conditions such as school lunch rules, budget, and nutritional balance. The generated menu and recipes are output by an application linked to the API, and school lunch operators can use this to replace nutritionists with AI.

[0055] Hardware and Software Used

[0056] Hardware:

[0057] Terminal (the device through which the user enters the conditions, e.g. PC, tablet, smartphone)

[0058] Server (for processing data and running generative AI models)

[0059] software:

[0060] A web interface or dedicated application (an interface for users to enter conditions)

[0061] Server-side programs (e.g. Python's Flask framework)

[0062] Generative AI models (e.g., GPT-4(R) from OpenAI(R))

[0063] API integration software (e.g. RESTful API)

[0064] Data processing and calculation

[0065] 1. The user enters the conditions

[0066] The user uses the terminal to input conditions such as school lunch rules, budget, nutritional balance, etc. For example, the user may input conditions such as "Create a menu for one week," "Budget per meal is within 500 yen," and "Calories are 600 kcal or less."

[0067] 2. The server receives the conditions

[0068] The conditions sent from the terminal are sent to the server as an HTTP request. The server receives the request and analyzes the conditions. For example, the server receives the request using the Python Flask framework.

[0069] 3. The server sends a prompt to the generative AI model

[0070] The server generates a prompt based on the received conditions and sends it to the generative AI model. For example, the prompt might be, "Please create a menu for one week. Please keep the budget per meal within 500 yen and calories below 600 kcal." The server sends this prompt to the generative AI model.

[0071] 4. A generative AI model generates menus

[0072] The generative AI model generates a menu based on the prompt sent in. For example, the generative AI model generates a menu such as "Monday: teriyaki chicken, spinach ohitashi, rice" or "Tuesday: grilled salmon, miso soup, salad."

[0073] 5. The server sends the generated menu to the API partner

[0074] The server sends the menu received from the generative AI model to the partner application via API. For example, the server sends data using a RESTful API. The partner application is a dedicated management system used by a food service provider.

[0075] 6. The device will display the results.

[0076] The terminal displays the menu received from the API-linked application. The user can check it and modify or regenerate it as necessary. For example, the user can send a request again such as "I want to change Monday's menu."

[0077] Examples

[0078] If a user enters the conditions "Create a menu for one week," "Budget per meal is less than 500 yen," and "Calories are less than 600 kcal," the system will generate a menu like the one below.

[0079] Monday: Teriyaki chicken, boiled spinach, rice

[0080] Tuesday: Grilled salmon, miso soup, salad

[0081] Wednesday: Pork with ginger, shredded cabbage, rice

[0082] Thursday: Curry rice, salad

[0083] Friday: Hamburger steak, potato salad, rice

[0084] Example prompt:

[0085] "Please create a menu for one week. Please limit each meal to 500 yen or less and keep the calories to 600 kcal or less."

[0086] In this way, users can easily specify conditions and efficiently generate menus through the system.

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

[0088] Step 1:

[0089] The user enters the conditions

[0090] Specific operation: The user uses a dedicated application on the device or a web interface to input conditions such as school lunch rules, budget, and nutritional balance.

[0091] Input: School lunch rules, budget, nutritional balance, and other conditions

[0092] Output: The entered condition data

[0093] Data processing: Convert the conditions entered by the user into a data format such as JSON.

[0094] Step 2:

[0095] The server receives the conditions

[0096] Specific operation: The conditions sent from the terminal are sent to the server as an HTTP request. The server receives this request and analyzes the conditions.

[0097] Input: Condition data entered by the user

[0098] Output: Parsed condition data

[0099] Data processing: The server analyzes the received condition data and converts it into a format that can be used internally.

[0100] Step 3:

[0101] The server sends prompts to the generative AI model

[0102] Specific operation: The server generates a prompt sentence based on the received conditions and sends it to the generative AI model.

[0103] Input: Parsed condition data

[0104] Output: The prompt sent to the generative AI model

[0105] Data processing: The server generates prompt sentences based on the condition data and converts them into a format suitable for the generative AI model.

[0106] Step 4:

[0107] A generative AI model generates menus

[0108] How it works: The generative AI model generates a menu based on the prompt text sent.

[0109] Input: prompt statement

[0110] Output: Generated menu data

[0111] Data processing: The generative AI model analyzes the prompt text and generates a menu that meets the conditions.

[0112] Step 5:

[0113] The server sends the generated menu to the API partner.

[0114] Specific operation: The server sends the menu received from the generative AI model to the linked application via API.

[0115] Input: Generated menu data

[0116] Output: Menu data sent to API partner

[0117] Data processing: The server converts the generated menu data into a format that can be received by the API-integrated application.

[0118] Step 6:

[0119] The terminal displays the results

[0120] Specific operation: The device displays the menu received from the API-linked application. The user can review it and modify or regenerate it as necessary.

[0121] Input: Menu data received from API partner

[0122] Output: Menu data displayed on the terminal

[0123] Data processing: The terminal converts the received menu data into a format that is easy for the user to view and displays it.

[0124] (Application example 1)

[0125] Next, a description will be given of Application Example 1 of Form 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."

[0126] In conventional school lunch systems, nutritionists had to manually create menus and manage food ordering and delivery, which was time-consuming and labor-intensive. In addition, creating menus that take nutritional balance and budget into account required specialized knowledge, making it difficult to do efficiently. Furthermore, ordering food and tracking delivery status were also done manually, which made it prone to errors and delays.

[0127] 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. In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying predetermined school lunch rules, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means for acquiring user input, a means for automatically ordering ingredients based on the generated menu, and a means for tracking and notifying the delivery status in real time. This enables efficient menu creation that takes nutritional balance and budget into consideration, and allows for integrated management from ordering ingredients to delivery.

[0128] "Generative AI" is artificial intelligence that automatically generates data based on specified conditions.

[0129] "Specified Period" refers to a specific period set by the User.

[0130] A "menu" is a list of the meals served during a particular period of time.

[0131] "School lunch rules" refers to regulations and guidelines regarding the provision of school lunches.

[0132] A "budget" refers to the maximum cost for ingredients or services for a particular period of time.

[0133] "Nutritional balance" refers to the appropriate distribution of nutrients necessary to maintain health.

[0134] A "recipe" is a list of steps and ingredients for making a particular dish.

[0135] An "API-integrated application" is an application that has an interface for exchanging data with other software or services.

[0136] "User Input" refers to information or data provided by a user to a system.

[0137] "Means for automatically ordering ingredients" refers to a function for automatically ordering necessary ingredients based on the generated menu.

[0138] "Means of tracking and notifying delivery status in real time" refers to a function that monitors the delivery status of ordered ingredients in real time and notifies the user.

[0139] The system for implementing this invention utilizes a generative AI model to automatically generate a menu for a specified period. A specific embodiment of this system will be described below.

[0140] System Configuration

[0141] 1. Getting user input:

[0142] Users use a device such as a smartphone or tablet to enter information such as the specified period, budget, and nutritional balance.

[0143] Hardware used: Smartphone, tablet

[0144] Software used: Mobile application (iOS / ANDROID (registered trademark))

[0145] 2. Invoke the generative AI model:

[0146] The server sends prompts to the generative AI model based on the user's input data and generates a menu for the specified period.

[0147] Software used: Generative AI models (e.g. OpenAI GPT-4)

[0148] Example prompt: "Please generate a menu for a 7-day period with a budget of 5,000 yen and a nutritional balance of high protein and low fat."

[0149] 3. Menu and recipe generation:

[0150] The server retrieves the menu and recipes returned by the generative AI model and displays them on the user's device.

[0151] Software used: Mobile application

[0152] 4. Automated food ordering:

[0153] The server then lists the ingredients needed based on the proposed menu and sends the order to a partner food delivery service.

[0154] Software used: API integration (e.g. food delivery service API)

[0155] 5. Tracking your delivery:

[0156] After the order is confirmed, the server tracks the delivery status in real time and notifies the user's terminal.

[0157] Software used: Mobile applications, notification systems (e.g. Firebase Cloud Messaging)

[0158] Examples

[0159] A user logs into the application using their smartphone and enters the following information:

[0160] Specified period: 7 days

[0161] Price: 5,000 yen

[0162] Nutritional balance: high protein, low fat

[0163] With this information, the server sends the following prompt to the generative AI model:

[0164] "Please create a menu for a specified period of 7 days, a budget of 5,000 yen, and a nutritionally balanced high protein, low fat menu."

[0165] The menu and recipes returned by the generative AI model are displayed on the user's smartphone. The user can review the suggested menu and the necessary ingredients are automatically ordered. Once the order is confirmed, the delivery status is tracked in real time and the user is notified.

[0166] In this way, users can easily create nutritionally balanced meal plans and manage everything from ordering ingredients to delivery all in one place.

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

[0168] Step 1:

[0169] A user uses a device such as a smartphone or tablet to input information such as a specified period, budget, and nutritional balance. The input information is sent from the device to a server. The input data includes a specified period (e.g., 7 days), budget (e.g., 5,000 yen), and nutritional balance (e.g., high protein, low fat).

[0170] Step 2:

[0171] The server receives the input data sent by the user, creates a prompt sentence, and sends it to the generative AI model. An example of a prompt sentence is, "Please generate a menu for the specified period of 7 days, the budget of 5,000 yen, and a nutritional balance of high protein and low fat." The server sends this prompt sentence to the generative AI model, instructing it to generate a menu for the specified period.

[0172] Step 3:

[0173] The generative AI model generates menus and recipes for the specified period based on the prompt text received from the server. The generative AI model analyzes the input data and generates the optimal menu taking into account the predefined school lunch rules, budget, and nutritional balance. The generated menus and recipes are returned to the server.

[0174] Step 4:

[0175] The server receives the menu and recipes returned from the generative AI model and transmits them to the user's terminal. The user's terminal displays the received menu and recipes. The user can confirm the suggested menu.

[0176] Step 5:

[0177] The server lists the ingredients required based on the proposed menu and sends an order to the partner food delivery service. The server sends the order data to the food delivery service using API integration. The order data includes the list and quantities of the ingredients required.

[0178] Step 6:

[0179] After the order is confirmed, the server tracks the delivery status in real time and notifies the user's terminal. The server receives delivery status data from the food delivery service and transmits it to the user's terminal. The user's terminal displays the delivery status in real time and notifies the user.

[0180] In this way, users can easily create nutritionally balanced meal plans and manage the entire process from ordering ingredients to delivery.

[0181] Example 2

[0182] Next, a second embodiment of the second embodiment will be described. 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."

[0183] The traditional process of creating school lunch menus is time-consuming and labor-intensive, as it is done manually by nutritionists. In addition, creating menus while taking into account nutritional balance and budgets is complicated, making it difficult to operate efficiently. Furthermore, the specialized knowledge of nutritionists is required, making it difficult to secure human resources. There is a demand for a system that can solve these problems and create school lunch menus efficiently and automatically.

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

[0185] In this invention, the server includes a means for a user to access the system, a means for a user to input school lunch rules, a budget, and nutritional balance, a means for the server to receive the input data and generate a prompt sentence for the generative AI model, a means for the server to send the prompt sentence to the generative AI model, a means for the generative AI model to generate a menu and recipes, a means for the server to send the generated menu and recipes to an application via an API, a means for the terminal to display the menu and recipes through the application, and a means for the user to check the menu and recipes and adjust them as necessary. This makes it possible to automate and streamline the creation of school lunch menus.

[0186] A "user" is a person or organization that accesses the system and inputs information such as school lunch rules, budget, and nutritional balance.

[0187] A "server" is a computer system that receives input data from a user, generates prompt sentences, and sends them to the generative AI model.

[0188] A "generative AI model" is an artificial intelligence model that automatically generates menus and recipes based on user input data.

[0189] A "prompt sentence" is text-based input data that provides instructions to a generative AI model.

[0190] An "API" is an interface for exchanging data between different software applications.

[0191] An "application" is a software program that a user accesses through a terminal and that displays the generated menus and recipes.

[0192] A "terminal" is a device (such as a PC, tablet, or smartphone) that a user uses to access the system.

[0193] A "menu" is a plan of meals to be served for a particular period of time.

[0194] A "recipe" is a list of specific steps and ingredients for cooking a meal based on a menu.

[0195] "School lunch rules" are specific conditions or standards regarding the provision of school lunches (e.g., serving fish once a week).

[0196] A "budget" is the maximum amount that can be spent on each school lunch meal.

[0197] "Nutritional balance" is a standard regarding the nutritional value of a meal, such as the calories per meal and the ratio of protein, fat, and carbohydrates.

[0198] This invention is a system for efficiently creating menus and recipes for school meal service providers. The system automatically generates menus and recipes using a generative AI model after the user inputs school meal rules, budget, and nutritional balance. A specific embodiment of this system is described below.

[0199] A user accesses the system's web application using a terminal (PC, tablet, smartphone, etc.). The user enters authentication information on the login screen and logs into the system. After logging in, the user moves to the dashboard screen and clicks the "Create a new menu" button. In the input form that is displayed, the user enters school lunch rules (e.g., provide fish once a week), budget (e.g., no more than 500 yen per meal), and nutritional balance (e.g., 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal), and clicks the "Submit" button.

[0200] The server receives the data entered by the user and generates a prompt sentence to be sent to the generative AI model based on the data. The prompt sentence is a text that specifically describes the user's requirements. For example, the following prompt sentence is generated:

[0201] Example prompt:

[0202] Create a school lunch menu for the week. The following conditions must be met:

[0203] Serve fish once a week

[0204] Budget is under 500 yen per meal

[0205] The nutritional balance is 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal.

[0206] The server sends the generated prompt sentence to the generative AI model. The generative AI model is an advanced natural language processing model such as OpenAI's GPT-3 (registered trademark). The generative AI model automatically generates menus and recipes for the specified period based on the received prompt sentence. The generated menus and recipes are returned to the server in text format.

[0207] The server receives the menu and recipes returned from the generative AI model and sends them to the linked application via API. The API uses, for example, a RESTful API. The application on the terminal displays the menu and recipes received from the server on the user interface. The user can visually check this.

[0208] The user can review the displayed menu and recipe and make adjustments as necessary, such as changing certain ingredients or adjusting portion sizes. Once adjustments are complete, the user can save the final menu and recipe.

[0209] This system allows school meal operators to create menus and recipes efficiently and automatically, significantly reducing time and labor. It also makes it easier to create menus that take into account nutritional balance and budgets, allowing them to provide high-quality school meals even without specialized knowledge.

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

[0211] Step 1:

[0212] A user accesses the system.

[0213] Input: A user uses a terminal to access the system's web application and enters login information.

[0214] Output: The user logs into the system and navigates to the dashboard screen.

[0215] Specific operations: A user opens a browser, enters the system URL, and accesses the system. On the login screen, the user enters the "user name" and "password," and clicks the "Login" button.

[0216] Step 2:

[0217] The user inputs school lunch rules, budget, and nutritional balance.

[0218] Input: The user clicks the "Create a new menu" button on the dashboard screen and enters school lunch rules, budget, and nutritional balance in the input form that appears.

[0219] Output: The data entered by the user is sent to the server.

[0220] Specific actions: The user clicks the "Create a new menu" button, enters the following into the input form that appears: "Provide fish once a week," "Budget is 500 yen or less per meal," "Calories 600 kcal, protein 20 g, fat 15 g, carbohydrates 80 g," and clicks the "Submit" button.

[0221] Step 3:

[0222] The server receives the input data and generates a prompt for the generative AI model.

[0223] Input: User-entered school lunch rules, budget, and nutritional balance data.

[0224] Output: The prompt to send to the generative AI model.

[0225] Specific operation: The server receives the user's input data and generates a prompt sentence saying, "Please create a school lunch menu for one week. The following conditions must be met: fish must be provided once a week, the budget must be within 500 yen per meal, and the nutritional balance must be 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal."

[0226] Step 4:

[0227] The server sends a prompt to the generative AI model.

[0228] Input: The generated prompt statement.

[0229] Output: The prompt is sent to the generative AI model.

[0230] Specific operation: The server sends the generated prompt text to the generative AI model.

[0231] Step 5:

[0232] A generative AI model generates menus and recipes.

[0233] Input: The prompt text sent by the server.

[0234] Output: Generated menu and recipes.

[0235] Specific operation: Based on the prompt, the generative AI model generates a menu and recipe, such as "Monday: grilled fish set meal, Tuesday: chicken curry, ...", and returns it to the server.

[0236] Step 6:

[0237] The server sends the generated menu and recipes to the application via an API.

[0238] Input: Meal plans and recipes returned by a generative AI model.

[0239] Output: The menu and recipes sent to the application.

[0240] Specific operation: The server receives the generated menu and recipes and sends them to the linked application via API.

[0241] Step 7:

[0242] The device displays menus and recipes through the application.

[0243] Input: Menu and recipes sent from the server.

[0244] Output: The menu and recipe displayed in a user interface.

[0245] Specific operation: The application on the device displays a menu and recipes such as "Monday: Grilled fish set meal, Tuesday: Chicken curry, ..."

[0246] Step 8:

[0247] User reviews menu and recipes and adjusts as needed.

[0248] Input: Displayed menu and recipe.

[0249] Output: Final, adjusted menu and recipes.

[0250] Specific actions: The user checks the displayed menu and recipes, makes adjustments such as "changing Tuesday's chicken curry to beef curry," and clicks the "Save" button.

[0251] (Application example 2)

[0252] Next, a description will be given of Application Example 2 of Form 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."

[0253] In conventional school lunch businesses and meal provision services, planning menus and managing nutritional balance was time-consuming and required specialized nutritionists. In addition, in order to meet the diverse needs of users, it was necessary to take into account individual dietary rules, budgets, and nutritional balance, which also placed a heavy burden on the users. There is a demand for a system that can solve these problems and generate and manage menus efficiently and flexibly.

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

[0255] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying predetermined dietary rules, budget, nutritional balance, etc., a means for generating the menu and recipes, a means for outputting in an application linked with the API, a means for generating the menu and recipes based on the dietary rules, budget, and nutritional balance specified by the user, and a means for confirming and adjusting the generated menu and recipes in a smartphone application. This enables the user to easily plan a nutritionally balanced menu and use a food delivery service.

[0256] "Generative AI" is artificial intelligence that automatically generates data based on specified rules and conditions.

[0257] A "menu" is a list of the meals served during a particular period of time.

[0258] A "recipe" is a detailed description of the steps and ingredients for making a particular dish.

[0259] A "dietary rule" refers to a specific condition or restriction regarding food, such as the use of a specific food ingredient once a week.

[0260] "Budget" refers to the financial constraints available for a specific period or conditions.

[0261] "Nutritional balance" refers to the appropriate proportions and amounts of nutrients contained in a meal.

[0262] An "API-integrated application" is an application that has an interface for exchanging data with other systems or services.

[0263] A "smartphone application" is a software program that runs on a smartphone.

[0264] "User" refers to any individual or organization that uses this system.

[0265] A "food delivery service" is a service that delivers meals ordered by a user to a specified location.

[0266] A system for implementing this invention includes means for automatically generating a menu for a specified period using generation AI, means for specifying pre-defined dietary rules, budget, nutritional balance, etc., means for generating menus and recipes, means for outputting in an application that is linked to the API, means for generating menus and recipes based on dietary rules, budget, and nutritional balance specified by the user, and means for checking and adjusting the generated menus and recipes within a smartphone application.

[0267] The server uses the generative AI model to generate menus and recipes based on the user's specified dietary rules, budget, and nutritional balance. Specifically, the generative AI model creates prompts based on information entered by the user through the smartphone application, and generates menus and recipes using the OpenAI API. The generated menus and recipes can be viewed within the smartphone application, and the user can make adjustments as necessary.

[0268] The hardware used is a smartphone, and the software is Python and OpenAI API. Data processing involves converting the dietary rules, budget, and nutritional balance entered by the user into prompt text and sending it to the generative AI model. Data calculation involves the generative AI model generating menus and recipes based on the prompt text.

[0269] As a specific example, if a user enters the conditions "include vegetarian menu once a week," "less than 500 yen per meal," and "600 calories, 20g protein, 10g fat, 80g carbohydrates per meal," the generation AI will generate a week's worth of menus and recipes that meet these conditions.

[0270] An example of a prompt is:

[0271] Menu rule: Include vegetarian menu once a week

[0272] Budget: Less than 500 yen per meal

[0273] Nutritionally balanced: 600 calories, 20g protein, 10g fat, 80g carbohydrates per serving

[0274] Use this information to generate a week's worth of menus and recipes.

[0275] In this way, users can easily plan nutritionally balanced meals and use food delivery services.

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

[0277] Step 1:

[0278] The user launches the smartphone application and inputs information such as dietary rules, budget, and nutritional balance.

[0279] Input: User-specified dietary rules, budget, nutritional balance

[0280] Output: Input condition data

[0281] Specific operation: The user enters conditions into the application's input form and presses the submit button.

[0282] Step 2:

[0283] The terminal transmits the input condition data to the server.

[0284] Input: Criteria data entered by the user

[0285] Output: Condition data sent to the server

[0286] Specific operation: The smartphone application makes an API request to send condition data to the server.

[0287] Step 3:

[0288] The server generates a prompt sentence based on the received condition data.

[0289] Input: Condition data sent to the server

[0290] Output: Generated prompt statement

[0291] Specific operation: The server parses the condition data and embeds the data into a template for generating a prompt sentence.

[0292] Step 4:

[0293] The server sends the generated prompt text to the OpenAI API to generate a menu and recipe.

[0294] Input: Generated prompt text

[0295] Output: Generated menu and recipe data

[0296] Specific operation: The server sends a prompt to the OpenAI API, and the generative AI model generates a menu and recipe.

[0297] Step 5:

[0298] The server transmits the generated menu and recipe data to the smartphone application.

[0299] Input: Generated menu and recipe data

[0300] Output: Menu and recipe data sent to the smartphone application

[0301] Specific operation: The server performs an API response to return the generated data to the smartphone application.

[0302] Step 6:

[0303] The terminal displays the received menu and recipe data, and the user can check and adjust it.

[0304] Input: Menu and recipe data sent to the smartphone application

[0305] Output: Menu and recipe data confirmed and adjusted by the user

[0306] Specific operation: The smartphone application displays the received data on the screen and provides an interface for the user to make adjustments as necessary.

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

[0308] "Example 1"

[0309] As one embodiment of the present invention, a system incorporating an emotion engine is provided. In this system, the generation AI includes an emotion engine that recognizes the user's emotion. Specifically, the generation AI recognizes the user's emotional state from information such as text, voice, and images input by the user to the system. This emotion engine can recognize the user's basic emotions, such as joy, sadness, anger, and surprise. Based on the recognition results, the generation AI automatically generates a menu. For example, if the user expresses joy, the generation AI incorporates ingredients and dishes that the user would like into the menu. Also, if the user expresses sadness, the generation AI incorporates ingredients and dishes that would cheer up the user into the menu. In this way, it is possible to generate a menu that takes into account the user's emotional state.

[0310] "Example 2"

[0311] Furthermore, as another embodiment of the present invention, a system is provided in which an emotion engine adjusts a recipe based on the emotion of a user. Specifically, the generation AI adjusts the recipe based on the recognition result of the emotion engine. For example, if a user shows an emotion of joy, the generation AI incorporates a recipe that the user would like into the recipe. Also, if a user shows an emotion of sadness, the generation AI incorporates a recipe that would cheer up the user. In this way, it is possible to adjust the recipe taking into account the emotional state of the user.

[0312] The process flow of each embodiment will be described below.

[0313] "Example 1"

[0314] Step 1: The user inputs information into the system. This information can be in various forms, such as text, audio, or images.

[0315] Step 2: The emotion engine recognizes the user's emotional state from the input information. This emotion engine has the ability to recognize basic emotions such as happiness, sadness, anger, and surprise.

[0316] Step 3: The generation AI automatically generates a menu based on the recognition results of the emotion engine. Depending on the user's emotional state, the generation AI selects ingredients and dishes to be included in the menu.

[0317] "Example 2"

[0318] Step 1: The user inputs information into the system. This information can be in various forms, such as text, audio, or images.

[0319] Step 2: The emotion engine recognizes the user's emotional state from the input information. This emotion engine has the ability to recognize basic emotions such as happiness, sadness, anger, and surprise.

[0320] Step 3: The generative AI adjusts the recipe based on the recognition results of the emotion engine. Depending on the user's emotional state, the generative AI selects the cooking methods to incorporate into the recipe.

[0321] Example 1

[0322] Next, a description will be given of Example 1 of the embodiment 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".

[0323] Conventional school lunch menu generation systems have the problem that it takes time and effort for nutritionists to create menus manually. In addition, it is not possible to generate menus that take into account the emotional state of the user, making it difficult to provide menus that meet the needs of individual users. Furthermore, there was a demand for a system that would allow school lunch operators to replace nutritionists with AI.

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

[0325] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying default school lunch rules, budget, nutritional balance, etc., a means for recognizing emotions from user input information, a means for generating a menu and recipes based on the recognized emotions, and a means for outputting in an application linked to the API. This makes it possible to generate a menu that takes into account the emotional state of the user, and provides a system that allows school lunch operators to replace nutritionists with AI.

[0326] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[0327] The "specified period" refers to a specific period set by the user, and serves as the basis for generating a menu within that period.

[0328] "School lunch rules" refer to the regulations and guidelines regarding the provision of school lunches, based on which the menu is generated.

[0329] A "budget" refers to the upper limit of costs that are taken into consideration when generating a menu, and serves as a standard for creating a menu within a specified amount.

[0330] "Nutritional balance" refers to the distribution of nutrients necessary to provide a healthy meal, and menus are created based on this.

[0331] "Means for recognizing emotions" refers to technology that analyzes and recognizes a user's emotional state from input information (text, voice, images, etc.).

[0332] An "API-integrated application" refers to software that interacts with the server to receive and display the generated menus and recipes.

[0333] A "nutritionist" is a professional who creates menus taking into account the nutritional balance of meals, and in this invention, the generative AI takes on that role.

[0334] This invention is a system that uses generation AI to automatically generate menus for a specified period. The system generates menus and recipes based on conditions such as school lunch rules, budgets, and nutritional balance. The generated menus and recipes are output to an application linked with the API and can be used by school lunch providers.

[0335] Hardware and Software Used

[0336] Hardware: Servers, terminals (PCs, smartphones)

[0337] Software: Generative AI models (e.g. GPT-4), emotion engines (e.g. IBM Watson(R) Tone Analyzer), API-linked applications

[0338] Explanation of program processing

[0339] User Input

[0340] The user uses a terminal to input conditions such as school lunch rules, budget, nutritional balance, etc. into the system. For example, the user might input, "Generate a menu for one week. The budget is 500 yen per day, and the nutritional balance is more vitamin C."

[0341] Emotion recognition by emotion engine

[0342] The server receives information such as text, voice, and images entered by the user and uses an emotion engine to recognize the user's emotional state. For example, if a user enters "I've been tired lately," the emotion engine recognizes the "feeling of fatigue."

[0343] Menu generation by generative AI

[0344] The server uses the generative AI model to generate menus and recipes based on the emotion engine's recognition results and the conditions specified by the user. For example, if the user expresses fatigue, the generative AI generates a menu using ingredients rich in vitamin C. Specifically, the generative AI model is input with the following prompt sentence:

[0345] "The user is tired, so please generate a week's worth of meals using ingredients rich in Vitamin C. The budget is 500 yen per day."

[0346] Output via API integration

[0347] The server outputs the generated menu and recipes to the linked application via the API. For example, the menu is displayed in an application used by a food service provider. Specifically, the server sends the generated data to the API endpoint via a POST request.

[0348] Examples

[0349] User input:

[0350] The user enters on the terminal, "Please generate a menu for one week. The budget is 500 yen per day, and the nutritional balance is more vitamin C" and clicks the send button.

[0351] Emotion Recognition with Emotion Engine:

[0352] The server receives the user's input and sends the text data to the emotion engine.

[0353] The emotion engine recognizes "fatigue" and returns the result to the server.

[0354] Menu generation by generative AI:

[0355] The server sends a prompt to the generative AI model based on the results of the emotion engine and the user's conditions.

[0356] The generative AI model generates the menu and returns the results to the server.

[0357] Output via API integration:

[0358] The server sends the generated menu data to the API endpoint via a POST request.

[0359] The application displays the received data so that the food service provider can review it.

[0360] In this way, the system performs a series of processes from user input, emotion recognition, menu generation, and output.

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

[0362] Step 1:

[0363] The user inputs the conditions.

[0364] The user uses a terminal to input conditions such as school lunch rules, budget, and nutritional balance into the system. For example, the user might input, "Generate a one-week menu. The budget is 500 yen per day, and the nutritional balance is more vitamin C," and then click the send button. The input data is sent to the server.

[0365] Step 2:

[0366] The server recognizes the user's emotions using an emotion engine.

[0367] The server receives text data entered by the user and sends it to the emotion engine. The emotion engine analyzes the text data and recognizes the user's emotional state. For example, in response to the input "I've been tired lately," the emotion engine recognizes "feeling tired" and returns the result to the server. The input is the user's text data, and the output is the recognized emotion data.

[0368] Step 3:

[0369] The server generates the menu using a generative AI model.

[0370] The server sends a prompt to the generative AI model based on the emotion engine's recognition results and the conditions specified by the user. For example, a prompt such as "The user is tired, so please generate a week's menu using ingredients rich in vitamin C. The budget is 500 yen per day" is sent to the generative AI model. The generative AI model generates menus and recipes based on this prompt and returns the results to the server. The input is the prompt, and the output is the generated menu data.

[0371] Step 4:

[0372] The server outputs the generated menu to the application via API.

[0373] The server sends the generated menu and recipe data to the API endpoint via a POST request. The API-integrated application displays the received data so that the food service provider can review it. The input is the generated menu data, and the output is the menu information displayed in the application.

[0374] In this way, the system performs a series of processes from user input, emotion recognition, menu generation, and output.

[0375] (Application example 1)

[0376] Next, a description will be given of Application Example 1 of Form 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."

[0377] Conventional menu generation systems can take into account school lunch rules and nutritional balance, but they cannot provide menus that reflect the user's emotional state. In addition, they lacked the functionality to link the generated menus to food delivery services, which resulted in low user convenience. This made it difficult to provide the optimal meal according to the user's emotions.

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

[0379] In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying a default school lunch rule, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means including an emotion engine for recognizing the emotional state of a user, a means for generating a menu based on the recognition result of the emotion engine, and a means for ordering the generated menu from a food delivery service. This makes it possible to generate a menu that takes into account the emotional state of the user, and further allows the generated menu to be ordered in conjunction with a food delivery service, improving user convenience.

[0380] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[0381] A "specified period" refers to a specific period set by the user, and serves as the basis for generating a menu within that period.

[0382] "School lunch rules" refer to regulations and guidelines regarding school lunches, and are the standards based on which menus are created.

[0383] A "budget" refers to the upper limit of expenses taken into consideration when creating a menu, and is a standard for setting economic constraints.

[0384] "Nutritional balance" refers to the distribution of nutrients necessary to provide a healthy diet, and is the standard for creating menus based on this.

[0385] "API-linked applications" refer to external software or services used to output the generated menus and recipes.

[0386] An "emotion engine" is a system for recognizing a user's emotional state from input information, and identifies basic emotions such as joy, sadness, anger, and surprise.

[0387] "Food delivery service" refers to a service that delivers meals ordered by a user to a specified location.

[0388] A "menu" refers to a menu of meals to be served within a specific period of time, and is automatically created by generative AI.

[0389] A "recipe" refers to a document that lists the steps and ingredients for preparing a dish based on a menu.

[0390] The system for implementing the present invention includes a generative AI, an emotion engine, and an API for linking with a food delivery service. A specific embodiment of the system will be described below.

[0391] System Configuration

[0392] The system consists of the following main components:

[0393] 1. Generative AI: Artificial intelligence that automatically generates menus and recipes based on specified conditions.

[0394] 2. Emotion engine: A system that recognizes the user's emotional state from input information.

[0395] 3. Food delivery service API: An interface for connecting the generated menu to a food delivery service to place an order.

[0396] Hardware and software used

[0397] Hardware: Smartphones, servers

[0398] Software: Python, OpenAI API, Food Delivery Service API

[0399] Data processing and calculation

[0400] 1. Emotion recognition: The user inputs their emotional state through their smartphone. The emotion engine analyzes the user's input information (text, voice, images, etc.) and recognizes their emotional state. For example, emotions are analyzed using OpenAI's API.

[0401] 2. Menu Generation: Based on the recognition results of the emotion engine, the generation AI generates the optimal menu. The generation AI creates a menu taking into account the user's emotional state, school lunch rules, budget, nutritional balance, and other conditions.

[0402] 3. Order integration: The generated menu is ordered through the food delivery service API. This allows users to easily order the generated menu.

[0403] Examples

[0404] If a user types "I'm so happy today!" into their smartphone, the emotion engine recognizes this as "joy." The generative AI then suggests "luxurious dishes like sushi and steak" based on this emotional state. The suggested menu is then ordered through a food delivery service API and delivered to the user's designated location.

[0405] Examples of prompt statements

[0406] Prompt for the emotion recognition engine:

[0407] User Input: I'm so happy today!

[0408] Recognize the emotion.

[0409] Prompt to menu generation engine:

[0410] Emotion: Joy

[0411] Generate a menu based on this emotion.

[0412] In this way, it becomes possible to generate a menu that takes into account the user's emotional state, and the generated menu can be ordered in conjunction with a food delivery service, thereby improving user convenience.

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

[0414] Step 1:

[0415] The user inputs his / her emotional state via a smartphone.

[0416] Input: The user's emotional state (e.g., "I'm so happy today!")

[0417] Actions: A smartphone application receives user input.

[0418] Output: User's emotional state text data

[0419] Step 2:

[0420] The server uses an emotion engine to recognize the user's emotional state.

[0421] Input: User's emotional state text data

[0422] How it works: The emotion engine (OpenAI API) analyzes text data and recognizes emotions.

[0423] Output: The recognized emotion (e.g. "joy")

[0424] Step 3:

[0425] The server uses generative AI to generate menus based on the recognized emotions.

[0426] Input: Recognized emotions (e.g., "joy"), school lunch rules, budget, nutritional balance

[0427] How it works: The generative AI takes these conditions into account and generates an optimal menu.

[0428] Output: Generated menu (e.g. "Luxurious dishes including sushi and steak")

[0429] Step 4:

[0430] The server sends the generated menu to the food delivery service API.

[0431] Input: Generated menu

[0432] How it works: The server sends the menu data to the food delivery service API and places the order.

[0433] Output: Order confirmation data from a food delivery service

[0434] Step 5:

[0435] The user receives an order confirmation on their smartphone.

[0436] Input: Order confirmation data from food delivery service

[0437] How it works: The smartphone application receives the order confirmation data and notifies the user.

[0438] Output: Order confirmation notification to user

[0439] In this way, it becomes possible to generate a menu that takes into account the user's emotional state, and the generated menu can be ordered in conjunction with a food delivery service, thereby improving user convenience.

[0440] Example 2

[0441] Next, a second embodiment of the second embodiment will be described. 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."

[0442] In conventional school lunch systems, creating menus and adjusting nutritional balance are done manually, which takes time and effort. In addition, it is difficult to respond to individual needs because recipes cannot be adjusted according to the user's emotions. This makes it difficult for school lunch operators to provide menus efficiently and flexibly.

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

[0444] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying default school lunch rules, budget, nutritional balance, etc., a means for generating the menu and recipes, a means for outputting in an application linked with the API, a means for recognizing the user's emotions using an emotion engine, and a means for adjusting the recipe based on the user's emotions. This enables school lunch operators to efficiently create menus and flexibly adjust recipes according to the user's emotions.

[0445] "Generative AI" refers to artificial intelligence that automatically generates menus and recipes based on specified conditions.

[0446] A "designated period" refers to a specific period set aside for creating school lunch menus and recipes.

[0447] "School lunch rules" refer to regulations and guidelines regarding the provision of school lunches, including specific instructions such as "serve fish once a week."

[0448] A "budget" is the maximum amount that can be spent on each school lunch.

[0449] "Nutritional balance" refers to the balance of nutrients, such as the calories per meal and the ratio of protein, fat, and carbohydrates.

[0450] An "API-integrated application" is an external application that receives the generated menus and recipes and displays and manages them.

[0451] An "emotion engine" is a technology that analyzes a user's facial expressions and voice and recognizes their emotions.

[0452] The "means for adjusting a recipe based on a user's emotions" refers to a means for modifying or adjusting a recipe in accordance with the user's emotions based on the recognition results of the emotion engine.

[0453] The present invention is a system for automatically generating menus and recipes for school meal service providers to efficiently adjust the menus and recipes according to the user's emotions. A specific embodiment of the system will be described below.

[0454] Hardware and Software Used

[0455] Hardware: Servers, terminals

[0456] Software: Generative AI models, emotion engines, API-integrated applications

[0457] System Overview

[0458] This system uses a generative AI model to automatically generate menus and recipes for a specified period, and an emotion engine to adjust the recipes based on the user's emotions. The user uses a terminal to input school lunch rules, budget, and nutritional balance, and the server receives and processes this information.

[0459] Program Processing

[0460] 1. Information entered by the user

[0461] The user uses the terminal to enter the following information:

[0462] School lunch rules (e.g., serve fish once a week)

[0463] Budget (e.g. 500 yen per meal)

[0464] Nutritionally balanced (e.g. 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving)

[0465] 2. Processing generative AI models

[0466] The server receives the information entered by the user and sends it as a prompt to the generative AI model, which then automatically generates menus and recipes for the specified period based on this information.

[0467] 3. Output to API-linked applications

[0468] The server sends the menu and recipes received from the generative AI model to an API-linked application, allowing users to check the generated menu and recipes on their devices.

[0469] 4. Emotion engine processing

[0470] The emotion engine analyzes the user's facial expressions and voice to recognize the user's emotions. The server sends the emotion engine's recognition results to the generative AI model, which then adjusts the recipe based on the emotions.

[0471] 5. Output of adjusted recipe

[0472] The server receives the adjusted recipe from the generative AI model and sends it back to the API-linked application, allowing the user to check the adjusted recipe on their device.

[0473] Examples

[0474] Information entered by the user:

[0475] School lunch rule: Serve fish once a week

[0476] Price: 500 yen per meal

[0477] Nutritionally balanced: 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving

[0478] Output of the generative AI model:

[0479] Monday: Fish stew

[0480] Tuesday: Teriyaki Chicken

[0481] Sentiment engine recognition results:

[0482] The user is expressing happiness

[0483] Adjusted recipe:

[0484] Monday: Fish stew (user adds preferred recipe)

[0485] Tuesday: Teriyaki Chicken (users add their favorite recipes)

[0486] In this way, the system provides optimal menus and recipes based on the user's input information and emotions, enabling food service providers to create menus efficiently and flexibly adjust recipes according to the user's emotions.

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

[0488] Step 1:

[0489] The user uses a terminal to input school lunch rules, budget, and nutritional balance.

[0490] Specifically, the user enters information such as "provide fish once a week," "500 yen per meal," and "600 calories, 20g protein, 15g fat, and 70g carbohydrates per meal" into an input form on the terminal.

[0491] Input: School lunch rules, budget, nutritional balance

[0492] Output: The entered information is sent to the server.

[0493] Step 2:

[0494] The server receives information entered by the user and sends prompts to the generative AI model.

[0495] Specifically, the server converts the received information into a prompt sentence and sends it to the generative AI model. An example of a prompt sentence is as follows:

[0496] School lunch rule: Serve fish once a week

[0497] Price: 500 yen per meal

[0498] Nutritionally balanced: 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving

[0499] Input: Information entered by the user

[0500] Output: The prompt sent to the generative AI model

[0501] Step 3:

[0502] The generative AI model automatically generates menus and recipes for the specified period based on the prompt text.

[0503] Specifically, the generative AI model analyzes the prompt text and generates menus and recipes that fit the conditions. For example, it generates a weekly menu of simmered fish on Mondays and teriyaki chicken on Tuesdays.

[0504] Input: Prompt statement

[0505] Output: Generated menu and recipes

[0506] Step 4:

[0507] The server sends the generated menu and recipes to the API-integrated application.

[0508] Specifically, the server sends the menu and recipes received from the generative AI model to an API-linked application so that the user can view them on their device.

[0509] Input: Generated menu and recipe

[0510] Output: Menu and recipes sent to API-connected applications

[0511] Step 5:

[0512] The user reviews the generated menu and recipes and adjusts them as necessary.

[0513] Specifically, the user checks the menu and recipes displayed on the device and makes adjustments if certain ingredients are unavailable.

[0514] Input: Menu and recipe displayed in API-linked application

[0515] Output: Menu and recipes adjusted by the user

[0516] Step 6:

[0517] The emotion engine recognizes the user's emotions.

[0518] Specifically, the emotion engine analyzes the user's facial expressions and voice to recognize the user's emotions, for example, determining whether the user is expressing an emotion of joy or sadness.

[0519] Input: User's facial expressions and voice

[0520] Output: Perceived user emotion

[0521] Step 7:

[0522] The server sends the results of the emotion engine to the generative AI model.

[0523] Specifically, the server sends the emotion engine's recognition results to the generative AI model and requests it to adjust the recipe based on the user's emotion. For example, it sends information that "the user is expressing the emotion of joy."

[0524] Input: Emotion engine recognition results

[0525] Output: Emotion information sent to the generative AI model

[0526] Step 8:

[0527] A generative AI model adjusts recipes based on emotions.

[0528] Specifically, the generative AI model will adjust the recipe based on the results of the emotion engine: for example, if the user expresses happiness, it will incorporate cooking methods that the user would prefer into the recipe.

[0529] Input: Emotion information

[0530] Output: Adjusted recipe

[0531] Step 9:

[0532] The server resends the adjusted recipe to the API-connected application.

[0533] Specifically, the server receives the adjusted recipe from the generative AI model and sends it back to the API-linked application, allowing the user to check the adjusted recipe on their device.

[0534] Input: Adjusted recipe

[0535] Output: Recipe resubmitted to API-connected application

[0536] (Application example 2)

[0537] Next, a description will be given of Application Example 2 of Form 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."

[0538] Conventional school lunch systems have the problem that the creation of menus and adjustment of nutritional balance are done manually, which takes time and effort. In addition, it is difficult to provide optimal meals for individual users because the recipes cannot be adjusted taking into account the emotional state of the user. Furthermore, food delivery services also have the problem of not being able to suggest menus that correspond to the user's preferences and emotions.

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

[0540] In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying a default school lunch rule, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means for analyzing a user's emotions using an emotion engine and adjusting a recipe based on the results, and a means including an application installed on a smartphone, smart glasses, a head-mounted display, or a robot. This makes it possible to propose optimal menus and recipes that take into account the user's emotional state.

[0541] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[0542] "Specified period" refers to a specific period set for generating menus and recipes.

[0543] "School lunch rules" refers to regulations and guidelines regarding the provision of school lunches, such as "serve fish once a week."

[0544] "Budget" refers to the upper limit of expenses taken into consideration when creating menus and recipes.

[0545] "Nutritional balance" refers to the ratio of calories, proteins, fats, carbohydrates, and other nutrients contained in a meal.

[0546] "API-linked applications" refer to external software or services used to output the generated menus and recipes.

[0547] An "emotion engine" refers to technology that analyzes the user's emotional state and adjusts recipes based on the results.

[0548] A "smartphone" refers to a mobile phone that can connect to the Internet and install applications.

[0549] "Smart glasses" refers to a glasses-type device that has the function of displaying information.

[0550] "Head-mounted display" refers to a display device that is worn on the head.

[0551] "Robot" refers to an automated machine that performs programmed actions.

[0552] The system for implementing the present invention includes a generative AI, an emotion engine, a smartphone, smart glasses, a head-mounted display, and a robot. Specific embodiments of the system are described below.

[0553] System Configuration

[0554] 1. Generation AI

[0555] The AI ​​automatically generates menus and recipes for a specified period based on the specified school lunch rules, budget, and nutritional balance. The AI ​​also suggests optimal menus based on the information entered by the user.

[0556] 2. Emotion Engine

[0557] The emotion engine analyzes the user's emotional state and provides the results to the generative AI. The emotion engine recognizes emotions from the user's facial expressions and voice, collecting data in real time.

[0558] 3. Smartphones, smart glasses, head-mounted displays, robots

[0559] These devices are used to display the generated menu and recipes to the user, who can then review the menu and make adjustments if necessary.

[0560] Program Processing

[0561] The server receives information on school lunch rules, budget, and nutritional balance entered by the user and sends it to the generation AI. The generation AI generates menus and recipes based on this information and makes adjustments taking into account the emotion data from the emotion engine. The generated menus and recipes are output to smartphones, smart glasses, head-mounted displays, and robots through API-linked applications.

[0562] Hardware and software used

[0563] Generation AI: OpenAI API

[0564] Emotion Engine: Emotion Engine API

[0565] Devices: Smartphones, smart glasses, head-mounted displays, robots

[0566] Examples

[0567] The user opens the smartphone app and enters the following information:

[0568] Budget: 1,000 yen

[0569] Nutritional balance: Calories 600kcal, Protein 20g, Fat 10g, Carbohydrates 50g

[0570] Allergies: Nuts

[0571] School lunch rule: serve fish once a week

[0572] If the emotion engine recognizes the user's emotion as "joy," the generative AI will receive the following prompt:

[0573] Examples of prompt statements

[0574] User Emotion: Delight

[0575] Price: 1000 yen

[0576] Nutritional balance: Calories 600kcal, Protein 20g, Fat 10g, Carbohydrates 50g

[0577] Allergies: Nuts

[0578] School lunch rules: serve fish once a week

[0579] Use this information to generate the best menus and recipes.

[0580] Based on these prompts, the AI ​​will generate menus and recipes and suggest them to the user. The user can then review the suggested menus via their smartphone, smart glasses, head-mounted display, or robot and make adjustments as necessary.

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

[0582] Step 1:

[0583] Users open the smartphone app and enter school lunch rules, budget, nutritional balance, and allergy information.

[0584] Input: User-entered school lunch rules, budget, nutritional balance, and allergy information

[0585] Output: The entered information is sent to the server.

[0586] Step 2:

[0587] The server receives the entered information and sends it to the generation AI.

[0588] Input: School lunch rules, budget, nutritional balance, allergy information sent by the user

[0589] Output: The prompt sent to the generation AI

[0590] Step 3:

[0591] The generative AI generates menus and recipes for the specified period based on the prompt text.

[0592] Input: Prompt statement

[0593] Output: Generated menu and recipes

[0594] Step 4:

[0595] The emotion engine analyzes the user's emotional state and sends the results to the server.

[0596] Input: User's facial expressions and voice data

[0597] Output: Parsed emotion data

[0598] Step 5:

[0599] The server receives the emotion data and sends it to the generation AI.

[0600] Input: Emotion data

[0601] Output: Emotion data sent to the generative AI

[0602] Step 6:

[0603] Generative AI adjusts menus and recipes based on emotional data.

[0604] Input: emotion data, generated menu and recipe

[0605] Output: Adjusted menu and recipes

[0606] Step 7:

[0607] The server sends the adjusted menu and recipes to the API-integrated application.

[0608] Input: Adjusted menu and recipe

[0609] Output: Data sent to the API-integrated application

[0610] Step 8:

[0611] Smartphones, smart glasses, head-mounted displays, and robots receive data from API-connected applications and display it to the user.

[0612] Input: Data received from the API-integrated application

[0613] Output: The menu and recipes displayed to the user

[0614] Step 9:

[0615] The user reviews the displayed menu and recipes and makes adjustments as necessary.

[0616] Input: Menu and recipes confirmed by the user

[0617] Output: Final, adjusted menu and recipe

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

[0619] 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<URL: https: / / openai.com / blog / chatgpt> ) and other generation AIs. The data generation model 58 is obtained by making a neural network perform deep learning. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating a voice, text data indicating a text, and image data indicating an image is input. The data generation model 58 performs inference on the input inference data according to 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.

[0620] Another example of generative AI is Gemini (registered trademark) (Internet search <url: https: gemini.google.com ?hl="ja">) are mentioned.

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

[0622] [Second embodiment]

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

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

[0625] 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 wide area network (WAN) and / or a local area network (LAN).

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

[0627] 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 the voice according to instructions from the processor 46.

[0628] Camera 42 is a small digital camera equipped with an optical system including a lens, an aperture, and a 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 (e.g., an imaging range defined by an angle of view equivalent to the width of the field of vision of an average healthy person).

[0629] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for transmitting and receiving various types of information between the processor 46 and the processor 28 via the network 54. The transmission and reception of various types of information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is performed in a secure state.

[0630] Fig. 4 shows an example of 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.

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

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

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

[0634] Next, the specific processing by the specific processing unit 290 of the data processing device 12 will be described.

[0635] "Example 1"

[0636] One embodiment of the present invention is a system that uses generation AI to automatically generate menus for a specified period. This system generates menus and recipes based on preset school lunch rules, budgets, nutritional balance, etc. The generated menus and recipes are output by an application linked to the API, and school lunch operators can use this to replace nutritionists with AI.

[0637] "Example 2"

[0638] As a specific example, consider the case where a school lunch provider uses this system. First, the school lunch provider specifies the school lunch rules (e.g., serving fish once a week), budget, and nutritional balance (e.g., calories per meal and the ratio of protein, fat, and carbohydrates) to the generation AI. Based on this information, the generation AI automatically generates menus and recipes for the specified period. The generated menus and recipes are output by an application linked to the API, and the school lunch provider can check them and make adjustments as necessary.

[0639] The process flow of each embodiment will be described below.

[0640] "Example 1"

[0641] Step 1: The school lunch provider specifies the default school lunch rules, budget, nutritional balance, etc. to the generation AI.

[0642] Step 2: The generation AI automatically generates menus and recipes for the specified period based on the specified information.

[0643] Step 3: The generated menu and recipes are output to the application that is linked to the API.

[0644] Step 4: The food service provider reviews the printed menu and recipes and makes adjustments as necessary.

[0645] "Example 2"

[0646] Step 1: The school lunch provider specifies the lunch rules (e.g., serving fish once a week), budget, and nutritional balance (e.g., calories per meal, and the ratio of protein, fat, and carbohydrates) to the generation AI.

[0647] Step 2: Based on this information, the generation AI automatically generates menus and recipes for the specified period.

[0648] Step 3: The generated menu and recipes are output to the application that is linked to the API.

[0649] Step 4: The food service provider reviews the printed menu and recipes and makes adjustments as necessary.

[0650] Example 1

[0651] Next, a description will be given of Example 1 of Form 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".

[0652] Traditionally, school lunch menus were created manually by nutritionists, which took time and effort, and it was difficult to consider budgets and nutritional balance. In addition, specialized knowledge of nutritionists was required, and it is often difficult for school lunch operators to secure human resources. This has created a demand for efficient and effective menu creation.

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

[0654] In this invention, the server includes a means for the user to input conditions, a means for the server to receive the conditions, a means for the server to send a prompt to the generation AI model, a means for the generation AI model to generate a menu, a means for the server to send the generated menu to an API partner, and a means for the terminal to display the results. This allows the user to easily specify conditions and efficiently generate a menu.

[0655] The "means for the user to input conditions" is an interface that allows the user to input conditions such as school lunch rules, budget, and nutritional balance.

[0656] The "means for the server to receive the conditions" is a function that enables the server to receive and analyze the conditions sent from the user.

[0657] "Means for the server to send a prompt to the generative AI model" refers to a function for generating a prompt sentence based on the conditions received by the server and sending it to the generative AI model.

[0658] "Means for the generative AI model to generate a menu" refers to the function by which the generative AI model automatically creates a menu that meets the specified conditions based on the prompt text sent to it.

[0659] "Means for the server to send the generated menu to the API partner" refers to a function that enables the server to send the menu received from the generative AI model to the partner application via API.

[0660] "Means for the terminal to display the results" refers to a function for displaying the menu received from the API-connected application on the user's terminal.

[0661] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0662] This invention is a system that uses a generative AI model to automatically generate a menu for a specified period. This system generates the menu and recipes based on the user's input of conditions such as school lunch rules, budget, and nutritional balance. The generated menu and recipes are output by an application linked to the API, and school lunch operators can use this to replace nutritionists with AI.

[0663] Hardware and Software Used

[0664] Hardware:

[0665] Terminal (the device through which the user enters the conditions, e.g. PC, tablet, smartphone)

[0666] Server (for processing data and running generative AI models)

[0667] software:

[0668] A web interface or dedicated application (an interface for users to enter conditions)

[0669] Server-side programs (e.g. Python's Flask framework)

[0670] Generative AI models (e.g. OpenAI's GPT-4)

[0671] API integration software (e.g. RESTful API)

[0672] Data processing and calculation

[0673] 1. The user enters the conditions

[0674] The user uses the terminal to input conditions such as school lunch rules, budget, nutritional balance, etc. For example, the user may input conditions such as "Create a menu for one week," "Budget per meal is within 500 yen," and "Calories are 600 kcal or less."

[0675] 2. The server receives the conditions

[0676] The conditions sent from the terminal are sent to the server as an HTTP request. The server receives the request and analyzes the conditions. For example, the server receives the request using the Python Flask framework.

[0677] 3. The server sends a prompt to the generative AI model

[0678] The server generates a prompt based on the received conditions and sends it to the generative AI model. For example, the prompt might be, "Please create a menu for one week. Please keep the budget per meal within 500 yen and calories below 600 kcal." The server sends this prompt to the generative AI model.

[0679] 4. A generative AI model generates menus

[0680] The generative AI model generates a menu based on the prompt sent in. For example, the generative AI model generates a menu such as "Monday: teriyaki chicken, spinach ohitashi, rice" or "Tuesday: grilled salmon, miso soup, salad."

[0681] 5. The server sends the generated menu to the API partner

[0682] The server sends the menu received from the generative AI model to the partner application via API. For example, the server sends data using a RESTful API. The partner application is a dedicated management system used by a food service provider.

[0683] 6. The device will display the results.

[0684] The terminal displays the menu received from the API-linked application. The user can check it and modify or regenerate it as necessary. For example, the user can send a request again such as "I want to change Monday's menu."

[0685] Examples

[0686] If a user enters the conditions "Create a menu for one week," "Budget per meal is less than 500 yen," and "Calories are less than 600 kcal," the system will generate a menu like the one below.

[0687] Monday: Teriyaki chicken, spinach salad, rice

[0688] Tuesday: Grilled salmon, miso soup, salad

[0689] Wednesday: Pork with ginger, shredded cabbage, rice

[0690] Thursday: Curry rice, salad

[0691] Friday: Hamburger steak, potato salad, rice

[0692] Example prompt:

[0693] "Please create a menu for one week. Please limit each meal to 500 yen or less and keep the calories to 600 kcal or less."

[0694] In this way, users can easily specify conditions and efficiently generate menus through the system.

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

[0696] Step 1:

[0697] The user enters the conditions

[0698] Specific operation: The user uses a dedicated application on the terminal or a web interface to input conditions such as school lunch rules, budget, and nutritional balance.

[0699] Input: School lunch rules, budget, nutritional balance, and other conditions

[0700] Output: The entered condition data

[0701] Data processing: Convert the conditions entered by the user into a data format such as JSON.

[0702] Step 2:

[0703] The server receives the conditions

[0704] Specific operation: The conditions sent from the terminal are sent to the server as an HTTP request. The server receives this request and analyzes the conditions.

[0705] Input: Condition data entered by the user

[0706] Output: Parsed condition data

[0707] Data processing: The server analyzes the received condition data and converts it into a format that can be used internally.

[0708] Step 3:

[0709] The server sends prompts to the generative AI model

[0710] Specific operation: The server generates a prompt sentence based on the received conditions and sends it to the generative AI model.

[0711] Input: Parsed condition data

[0712] Output: The prompt sent to the generative AI model

[0713] Data processing: The server generates prompt sentences based on the condition data and converts them into a format suitable for the generative AI model.

[0714] Step 4:

[0715] A generative AI model generates menus

[0716] How it works: The generative AI model generates a menu based on the prompt text sent.

[0717] Input: prompt statement

[0718] Output: Generated menu data

[0719] Data processing: The generative AI model analyzes the prompt text and generates a menu that meets the conditions.

[0720] Step 5:

[0721] The server sends the generated menu to the API partner.

[0722] Specific operation: The server sends the menu received from the generative AI model to the linked application via API.

[0723] Input: Generated menu data

[0724] Output: Menu data sent to API partner

[0725] Data processing: The server converts the generated menu data into a format that can be received by the API-integrated application.

[0726] Step 6:

[0727] The terminal displays the results

[0728] Specific operation: The device displays the menu received from the API-linked application. The user can review it and modify or regenerate it as necessary.

[0729] Input: Menu data received from API partner

[0730] Output: Menu data displayed on the terminal

[0731] Data processing: The terminal converts the received menu data into a format that is easy for the user to view and displays it.

[0732] (Application example 1)

[0733] Next, a description will be given of Application Example 1 of Form 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".

[0734] In conventional school lunch systems, nutritionists had to manually create menus and manage food ordering and delivery, which was time-consuming and labor-intensive. In addition, creating menus that take nutritional balance and budget into account required specialized knowledge, making it difficult to do efficiently. Furthermore, ordering food and tracking delivery status were also done manually, which made it prone to errors and delays.

[0735] 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. In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying predetermined school lunch rules, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means for acquiring user input, a means for automatically ordering ingredients based on the generated menu, and a means for tracking and notifying the delivery status in real time. This enables efficient menu creation that takes nutritional balance and budget into consideration, and allows for integrated management from ordering ingredients to delivery.

[0736] "Generative AI" is artificial intelligence that automatically generates data based on specified conditions.

[0737] "Specified Period" refers to a specific period set by the User.

[0738] A "menu" is a list of the meals served during a particular period of time.

[0739] "School lunch rules" refers to regulations and guidelines regarding the provision of school lunches.

[0740] A "budget" refers to the maximum cost for ingredients or services for a particular period of time.

[0741] "Nutritional balance" refers to the appropriate distribution of nutrients necessary to maintain health.

[0742] A "recipe" is a list of steps and ingredients for making a particular dish.

[0743] An "API-integrated application" is an application that has an interface for exchanging data with other software or services.

[0744] "User Input" refers to information or data provided by a user to a system.

[0745] "Means for automatically ordering ingredients" refers to a function for automatically ordering necessary ingredients based on the generated menu.

[0746] "Means of tracking and notifying delivery status in real time" refers to a function that monitors the delivery status of ordered ingredients in real time and notifies the user.

[0747] The system for implementing this invention utilizes a generative AI model to automatically generate a menu for a specified period. A specific embodiment of this system will be described below.

[0748] System Configuration

[0749] 1. Getting user input:

[0750] Users use a device such as a smartphone or tablet to enter information such as the specified period, budget, and nutritional balance.

[0751] Hardware used: Smartphone, tablet

[0752] Software used: Mobile application (iOS / Android)

[0753] 2. Invoke the generative AI model:

[0754] The server sends prompts to the generative AI model based on the user's input data and generates a menu for the specified period.

[0755] Software used: Generative AI models (e.g. OpenAI GPT-4)

[0756] Example prompt: "Please generate a menu for a 7-day period with a budget of 5,000 yen and a nutritional balance of high protein and low fat."

[0757] 3. Menu and recipe generation:

[0758] The server retrieves the menu and recipes returned by the generative AI model and displays them on the user's device.

[0759] Software used: Mobile application

[0760] 4. Automated food ordering:

[0761] The server then lists the ingredients needed based on the proposed menu and sends the order to a partner food delivery service.

[0762] Software used: API integration (e.g. food delivery service API)

[0763] 5. Tracking your delivery:

[0764] After the order is confirmed, the server tracks the delivery status in real time and notifies the user's terminal.

[0765] Software used: Mobile applications, notification systems (e.g. Firebase Cloud Messaging)

[0766] Examples

[0767] A user logs into the application using their smartphone and enters the following information:

[0768] Specified period: 7 days

[0769] Price: 5,000 yen

[0770] Nutritional balance: high protein, low fat

[0771] With this information, the server sends the following prompt to the generative AI model:

[0772] "Please create a menu for a specified period of 7 days, a budget of 5,000 yen, and a nutritionally balanced high protein, low fat menu."

[0773] The menu and recipes returned by the generative AI model are displayed on the user's smartphone. The user can review the suggested menu and the necessary ingredients are automatically ordered. Once the order is confirmed, the delivery status is tracked in real time and the user is notified.

[0774] In this way, users can easily create nutritionally balanced meal plans and manage everything from ordering ingredients to delivery all in one place.

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

[0776] Step 1:

[0777] A user uses a device such as a smartphone or tablet to input information such as a specified period, budget, and nutritional balance. The input information is sent from the device to a server. The input data includes a specified period (e.g., 7 days), budget (e.g., 5,000 yen), and nutritional balance (e.g., high protein, low fat).

[0778] Step 2:

[0779] The server receives the input data sent by the user, creates a prompt sentence, and sends it to the generative AI model. An example of a prompt sentence is, "Please generate a menu for the specified period of 7 days, the budget of 5,000 yen, and a nutritional balance of high protein and low fat." The server sends this prompt sentence to the generative AI model, instructing it to generate a menu for the specified period.

[0780] Step 3:

[0781] The generative AI model generates menus and recipes for the specified period based on the prompt text received from the server. The generative AI model analyzes the input data and generates the optimal menu taking into account the predefined school lunch rules, budget, and nutritional balance. The generated menus and recipes are returned to the server.

[0782] Step 4:

[0783] The server receives the menu and recipes returned from the generative AI model and transmits them to the user's terminal. The user's terminal displays the received menu and recipes. The user can confirm the suggested menu.

[0784] Step 5:

[0785] The server lists the ingredients required based on the proposed menu and sends an order to the partner food delivery service. The server sends the order data to the food delivery service using API integration. The order data includes the list and quantities of the ingredients required.

[0786] Step 6:

[0787] After the order is confirmed, the server tracks the delivery status in real time and notifies the user's terminal. The server receives delivery status data from the food delivery service and transmits it to the user's terminal. The user's terminal displays the delivery status in real time and notifies the user.

[0788] In this way, users can easily create nutritionally balanced meal plans and manage the entire process from ordering ingredients to delivery.

[0789] Example 2

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

[0791] The traditional process of creating school lunch menus is time-consuming and labor-intensive, as it is done manually by nutritionists. In addition, creating menus while taking into account nutritional balance and budgets is complicated, making it difficult to operate efficiently. Furthermore, the specialized knowledge of nutritionists is required, making it difficult to secure human resources. There is a demand for a system that can solve these problems and create school lunch menus efficiently and automatically.

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

[0793] In this invention, the server includes a means for a user to access the system, a means for a user to input school lunch rules, a budget, and nutritional balance, a means for the server to receive the input data and generate a prompt sentence for the generative AI model, a means for the server to send the prompt sentence to the generative AI model, a means for the generative AI model to generate a menu and recipes, a means for the server to send the generated menu and recipes to an application via an API, a means for the terminal to display the menu and recipes through the application, and a means for the user to check the menu and recipes and adjust them as necessary. This makes it possible to automate and streamline the creation of school lunch menus.

[0794] A "user" is a person or organization that accesses the system and inputs information such as school lunch rules, budget, and nutritional balance.

[0795] A "server" is a computer system that receives input data from a user, generates prompt sentences, and sends them to the generative AI model.

[0796] A "generative AI model" is an artificial intelligence model that automatically generates menus and recipes based on user input data.

[0797] A "prompt sentence" is text-based input data that provides instructions to a generative AI model.

[0798] An "API" is an interface for exchanging data between different software applications.

[0799] An "application" is a software program that a user accesses through a terminal and that displays the generated menus and recipes.

[0800] A "terminal" is a device (such as a PC, tablet, or smartphone) that a user uses to access the system.

[0801] A "menu" is a plan of meals to be served for a particular period of time.

[0802] A "recipe" is a list of specific steps and ingredients for cooking a meal based on a menu.

[0803] "School lunch rules" are specific conditions or standards regarding the provision of school lunches (e.g., serving fish once a week).

[0804] A "budget" is the maximum amount that can be spent on each school lunch meal.

[0805] "Nutritional balance" is a standard regarding the nutritional value of a meal, such as the calories per meal and the ratio of protein, fat, and carbohydrates.

[0806] This invention is a system for efficiently creating menus and recipes for school meal service providers. The system automatically generates menus and recipes using a generative AI model after the user inputs school meal rules, budget, and nutritional balance. A specific embodiment of this system is described below.

[0807] A user accesses the system's web application using a terminal (PC, tablet, smartphone, etc.). The user enters authentication information on the login screen and logs into the system. After logging in, the user moves to the dashboard screen and clicks the "Create a new menu" button. In the input form that is displayed, the user enters school lunch rules (e.g., provide fish once a week), budget (e.g., no more than 500 yen per meal), and nutritional balance (e.g., 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal), and clicks the "Submit" button.

[0808] The server receives the data entered by the user and generates a prompt to be sent to the generative AI model based on the data. The prompt is a text that specifically describes the user's requirements. For example, the following prompt is generated:

[0809] Example prompt:

[0810] Create a school lunch menu for the week. The following conditions must be met:

[0811] Serve fish once a week

[0812] Budget is under 500 yen per meal

[0813] The nutritional balance is 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal.

[0814] The server sends the generated prompt to the generative AI model, which is an advanced natural language processing model such as OpenAI's GPT-3. The generative AI model automatically generates menus and recipes for the specified period based on the received prompt. The generated menus and recipes are returned to the server in text format.

[0815] The server receives the menu and recipes returned from the generative AI model and sends them to the linked application via API. The API uses, for example, a RESTful API. The application on the terminal displays the menu and recipes received from the server on the user interface. The user can visually check this.

[0816] The user can review the displayed menu and recipe and make adjustments as necessary, such as changing certain ingredients or adjusting portion sizes. Once adjustments are complete, the user can save the final menu and recipe.

[0817] This system allows school meal operators to create menus and recipes efficiently and automatically, significantly reducing time and labor. It also makes it easier to create menus that take into account nutritional balance and budgets, allowing them to provide high-quality school meals even without specialized knowledge.

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

[0819] Step 1:

[0820] A user accesses the system.

[0821] Input: A user uses a terminal to access the system's web application and enters login information.

[0822] Output: The user logs into the system and navigates to the dashboard screen.

[0823] Specific operations: A user opens a browser, enters the system URL, and accesses the system. On the login screen, the user enters the "user name" and "password," and clicks the "Login" button.

[0824] Step 2:

[0825] The user inputs school lunch rules, budget, and nutritional balance.

[0826] Input: The user clicks the "Create a new menu" button on the dashboard screen and enters school lunch rules, budget, and nutritional balance in the input form that appears.

[0827] Output: The data entered by the user is sent to the server.

[0828] Specific actions: The user clicks the "Create a new menu" button, enters the following into the input form that appears: "Provide fish once a week," "Budget is 500 yen or less per meal," "Calories 600 kcal, protein 20 g, fat 15 g, carbohydrates 80 g," and clicks the "Submit" button.

[0829] Step 3:

[0830] The server receives the input data and generates a prompt for the generative AI model.

[0831] Input: User-entered school lunch rules, budget, and nutritional balance data.

[0832] Output: The prompt to send to the generative AI model.

[0833] Specific operation: The server receives the user's input data and generates a prompt sentence saying, "Please create a school lunch menu for one week. The following conditions must be met: fish must be provided once a week, the budget must be within 500 yen per meal, and the nutritional balance must be 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal."

[0834] Step 4:

[0835] The server sends a prompt to the generative AI model.

[0836] Input: The generated prompt statement.

[0837] Output: The prompt is sent to the generative AI model.

[0838] Specific operation: The server sends the generated prompt text to the generative AI model.

[0839] Step 5:

[0840] A generative AI model generates menus and recipes.

[0841] Input: The prompt text sent by the server.

[0842] Output: Generated menu and recipes.

[0843] Specific operation: Based on the prompt, the generative AI model generates a menu and recipe, such as "Monday: grilled fish set meal, Tuesday: chicken curry, ...", and returns it to the server.

[0844] Step 6:

[0845] The server sends the generated menu and recipes to the application via an API.

[0846] Input: Meal plans and recipes returned by a generative AI model.

[0847] Output: The menu and recipes sent to the application.

[0848] Specific operation: The server receives the generated menu and recipes and sends them to the linked application via API.

[0849] Step 7:

[0850] The device displays menus and recipes through the application.

[0851] Input: Menu and recipes sent from the server.

[0852] Output: The menu and recipe displayed in a user interface.

[0853] Specific operation: The application on the device displays a menu and recipes such as "Monday: Grilled fish set meal, Tuesday: Chicken curry, ..."

[0854] Step 8:

[0855] User reviews menu and recipes and adjusts as needed.

[0856] Input: Displayed menu and recipe.

[0857] Output: Final, adjusted menu and recipes.

[0858] Specific actions: The user checks the displayed menu and recipes, makes adjustments such as "changing Tuesday's chicken curry to beef curry," and clicks the "Save" button.

[0859] (Application example 2)

[0860] Next, a description will be given of Application Example 2 of Form 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".

[0861] In conventional school lunch businesses and meal provision services, planning menus and managing nutritional balance was time-consuming and required specialized nutritionists. In addition, in order to meet the diverse needs of users, it was necessary to take into account individual dietary rules, budgets, and nutritional balance, which also placed a heavy burden on the users. There is a demand for a system that can solve these problems and generate and manage menus efficiently and flexibly.

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

[0863] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying predetermined dietary rules, budget, nutritional balance, etc., a means for generating the menu and recipes, a means for outputting in an application linked with the API, a means for generating the menu and recipes based on the dietary rules, budget, and nutritional balance specified by the user, and a means for confirming and adjusting the generated menu and recipes in a smartphone application. This enables the user to easily plan a nutritionally balanced menu and use a food delivery service.

[0864] "Generative AI" is artificial intelligence that automatically generates data based on specified rules and conditions.

[0865] A "menu" is a list of the meals served during a particular period of time.

[0866] A "recipe" is a detailed description of the steps and ingredients for making a particular dish.

[0867] A "dietary rule" refers to a specific condition or restriction regarding food, such as the use of a specific food ingredient once a week.

[0868] "Budget" refers to the financial constraints available for a specific period or conditions.

[0869] "Nutritional balance" refers to the appropriate proportions and amounts of nutrients contained in a meal.

[0870] An "API-integrated application" is an application that has an interface for exchanging data with other systems or services.

[0871] A "smartphone application" is a software program that runs on a smartphone.

[0872] "User" refers to any individual or organization that uses this system.

[0873] A "food delivery service" is a service that delivers meals ordered by a user to a specified location.

[0874] A system for implementing this invention includes means for automatically generating a menu for a specified period using generation AI, means for specifying pre-defined dietary rules, budget, nutritional balance, etc., means for generating menus and recipes, means for outputting in an application that is linked to the API, means for generating menus and recipes based on dietary rules, budget, and nutritional balance specified by the user, and means for checking and adjusting the generated menus and recipes within a smartphone application.

[0875] The server uses the generative AI model to generate menus and recipes based on the user's specified dietary rules, budget, and nutritional balance. Specifically, the generative AI model creates prompts based on information entered by the user through the smartphone application, and generates menus and recipes using the OpenAI API. The generated menus and recipes can be viewed within the smartphone application, and the user can make adjustments as necessary.

[0876] The hardware used is a smartphone, and the software is Python and OpenAI API. Data processing involves converting the dietary rules, budget, and nutritional balance entered by the user into prompt text and sending it to the generative AI model. Data calculation involves the generative AI model generating menus and recipes based on the prompt text.

[0877] As a specific example, if a user enters the conditions "include vegetarian menu once a week," "less than 500 yen per meal," and "600 calories, 20g protein, 10g fat, 80g carbohydrates per meal," the generation AI will generate a week's worth of menus and recipes that meet these conditions.

[0878] An example of a prompt is:

[0879] Menu rule: Include vegetarian menu once a week

[0880] Budget: Less than 500 yen per meal

[0881] Nutritionally balanced: 600 calories, 20g protein, 10g fat, 80g carbohydrates per serving

[0882] Use this information to generate a week's worth of menus and recipes.

[0883] In this way, users can easily plan nutritionally balanced meals and use food delivery services.

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

[0885] Step 1:

[0886] The user launches the smartphone application and inputs information such as dietary rules, budget, and nutritional balance.

[0887] Input: User-specified dietary rules, budget, nutritional balance

[0888] Output: Input condition data

[0889] Specific operation: The user enters conditions into the application's input form and presses the submit button.

[0890] Step 2:

[0891] The terminal transmits the input condition data to the server.

[0892] Input: Criteria data entered by the user

[0893] Output: Condition data sent to the server

[0894] Specific operation: The smartphone application makes an API request to send condition data to the server.

[0895] Step 3:

[0896] The server generates a prompt sentence based on the received condition data.

[0897] Input: Condition data sent to the server

[0898] Output: Generated prompt statement

[0899] Specific operation: The server parses the condition data and embeds the data into a template for generating a prompt sentence.

[0900] Step 4:

[0901] The server sends the generated prompt text to the OpenAI API to generate a menu and recipe.

[0902] Input: Generated prompt text

[0903] Output: Generated menu and recipe data

[0904] Specific operation: The server sends a prompt to the OpenAI API, and the generative AI model generates a menu and recipe.

[0905] Step 5:

[0906] The server transmits the generated menu and recipe data to the smartphone application.

[0907] Input: Generated menu and recipe data

[0908] Output: Menu and recipe data sent to the smartphone application

[0909] Specific operation: The server performs an API response to return the generated data to the smartphone application.

[0910] Step 6:

[0911] The terminal displays the received menu and recipe data, and the user can check and adjust it.

[0912] Input: Menu and recipe data sent to the smartphone application

[0913] Output: Menu and recipe data confirmed and adjusted by the user

[0914] Specific operation: The smartphone application displays the received data on the screen and provides an interface for the user to make adjustments as necessary.

[0915] In addition, 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.

[0916] "Example 1"

[0917] As one embodiment of the present invention, a system incorporating an emotion engine is provided. In this system, the generation AI includes an emotion engine that recognizes the user's emotion. Specifically, the generation AI recognizes the user's emotional state from information such as text, voice, and images input by the user to the system. This emotion engine can recognize the user's basic emotions, such as joy, sadness, anger, and surprise. Based on the recognition results, the generation AI automatically generates a menu. For example, if the user expresses joy, the generation AI incorporates ingredients and dishes that the user would like into the menu. Also, if the user expresses sadness, the generation AI incorporates ingredients and dishes that would cheer up the user into the menu. In this way, it is possible to generate a menu that takes into account the user's emotional state.

[0918] "Example 2"

[0919] Furthermore, as another embodiment of the present invention, a system is provided in which an emotion engine adjusts a recipe based on the emotion of a user. Specifically, the generation AI adjusts the recipe based on the recognition result of the emotion engine. For example, if a user shows an emotion of joy, the generation AI incorporates a recipe that the user would like into the recipe. Also, if a user shows an emotion of sadness, the generation AI incorporates a recipe that would cheer up the user. In this way, it is possible to adjust the recipe taking into account the emotional state of the user.

[0920] The process flow of each embodiment will be described below.

[0921] "Example 1"

[0922] Step 1: The user inputs information into the system. This information can be in various forms, such as text, audio, or images.

[0923] Step 2: The emotion engine recognizes the user's emotional state from the input information. This emotion engine has the ability to recognize basic emotions such as happiness, sadness, anger, and surprise.

[0924] Step 3: The generation AI automatically generates a menu based on the recognition results of the emotion engine. Depending on the user's emotional state, the generation AI selects ingredients and dishes to be included in the menu.

[0925] "Example 2"

[0926] Step 1: The user inputs information into the system. This information can be in various forms, such as text, audio, or images.

[0927] Step 2: The emotion engine recognizes the user's emotional state from the input information. This emotion engine has the ability to recognize basic emotions such as happiness, sadness, anger, and surprise.

[0928] Step 3: The generative AI adjusts the recipe based on the recognition results of the emotion engine. Depending on the user's emotional state, the generative AI selects the cooking methods to incorporate into the recipe.

[0929] Example 1

[0930] Next, a description will be given of Example 1 of Form 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".

[0931] Conventional school lunch menu generation systems have the problem that it takes time and effort for nutritionists to create menus manually. In addition, it is not possible to generate menus that take into account the emotional state of the user, making it difficult to provide menus that meet the needs of individual users. Furthermore, there was a demand for a system that would allow school lunch operators to replace nutritionists with AI.

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

[0933] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying default school lunch rules, budget, nutritional balance, etc., a means for recognizing emotions from user input information, a means for generating a menu and recipes based on the recognized emotions, and a means for outputting in an application linked to the API. This makes it possible to generate a menu that takes into account the emotional state of the user, and provides a system that allows school lunch operators to replace nutritionists with AI.

[0934] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[0935] The "specified period" refers to a specific period set by the user, and serves as the basis for generating a menu within that period.

[0936] "School lunch rules" refer to the regulations and guidelines regarding the provision of school lunches, based on which the menu is generated.

[0937] A "budget" refers to the upper limit of costs that are taken into consideration when generating a menu, and serves as a standard for creating a menu within a specified amount.

[0938] "Nutritional balance" refers to the distribution of nutrients necessary to provide a healthy meal, and menus are created based on this.

[0939] "Means for recognizing emotions" refers to technology that analyzes and recognizes a user's emotional state from input information (text, voice, images, etc.).

[0940] An "API-integrated application" refers to software that interacts with the server to receive and display the generated menus and recipes.

[0941] A "nutritionist" is a professional who creates menus taking into account the nutritional balance of meals, and in this invention, the generative AI takes on that role.

[0942] This invention is a system that uses generation AI to automatically generate menus for a specified period. The system generates menus and recipes based on conditions such as school lunch rules, budgets, and nutritional balance. The generated menus and recipes are output to an application linked with the API and can be used by school lunch providers.

[0943] Hardware and Software Used

[0944] Hardware: Servers, terminals (PCs, smartphones)

[0945] Software: Generative AI models (e.g. GPT-4), emotion engines (e.g. IBM Watson Tone Analyzer), API-integrated applications

[0946] Explanation of program processing

[0947] User Input

[0948] The user uses a terminal to input conditions such as school lunch rules, budget, nutritional balance, etc. into the system. For example, the user might input, "Generate a menu for one week. The budget is 500 yen per day, and the nutritional balance is more vitamin C."

[0949] Emotion recognition by emotion engine

[0950] The server receives information such as text, voice, and images entered by the user and uses an emotion engine to recognize the user's emotional state. For example, if a user enters "I've been tired lately," the emotion engine recognizes the "feeling of fatigue."

[0951] Menu generation by generative AI

[0952] The server uses the generative AI model to generate menus and recipes based on the emotion engine's recognition results and the conditions specified by the user. For example, if the user expresses fatigue, the generative AI generates a menu using ingredients rich in vitamin C. Specifically, the generative AI model is input with the following prompt sentence:

[0953] "The user is tired, so please generate a week's worth of meals using ingredients rich in Vitamin C. The budget is 500 yen per day."

[0954] Output via API integration

[0955] The server outputs the generated menu and recipes to the linked application via the API. For example, the menu is displayed in an application used by a food service provider. Specifically, the server sends the generated data to the API endpoint via a POST request.

[0956] Examples

[0957] User input:

[0958] The user enters on the terminal, "Please generate a menu for one week. The budget is 500 yen per day, and the nutritional balance is more vitamin C" and clicks the send button.

[0959] Emotion Recognition with Emotion Engine:

[0960] The server receives the user's input and sends the text data to the emotion engine.

[0961] The emotion engine recognizes "fatigue" and returns the result to the server.

[0962] Menu generation by generative AI:

[0963] The server sends a prompt to the generative AI model based on the results of the emotion engine and the user's conditions.

[0964] The generative AI model generates the menu and returns the results to the server.

[0965] Output via API integration:

[0966] The server sends the generated menu data to the API endpoint via a POST request.

[0967] The application displays the received data so that the food service provider can review it.

[0968] In this way, the system performs a series of processes from user input, emotion recognition, menu generation, and output.

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

[0970] Step 1:

[0971] The user inputs the conditions.

[0972] The user uses a terminal to input conditions such as school lunch rules, budget, and nutritional balance into the system. For example, the user might input, "Generate a one-week menu. The budget is 500 yen per day, and the nutritional balance is more vitamin C," and then click the send button. The input data is sent to the server.

[0973] Step 2:

[0974] The server recognizes the user's emotions using an emotion engine.

[0975] The server receives text data entered by the user and sends it to the emotion engine. The emotion engine analyzes the text data and recognizes the user's emotional state. For example, in response to the input "I've been tired lately," the emotion engine recognizes "feeling tired" and returns the result to the server. The input is the user's text data, and the output is the recognized emotion data.

[0976] Step 3:

[0977] The server generates the menu using a generative AI model.

[0978] The server sends a prompt to the generative AI model based on the emotion engine's recognition results and the conditions specified by the user. For example, a prompt such as "The user is tired, so please generate a week's menu using ingredients rich in vitamin C. The budget is 500 yen per day" is sent to the generative AI model. The generative AI model generates menus and recipes based on this prompt and returns the results to the server. The input is the prompt, and the output is the generated menu data.

[0979] Step 4:

[0980] The server outputs the generated menu to the application via API.

[0981] The server sends the generated menu and recipe data to the API endpoint via a POST request. The API-integrated application displays the received data so that the food service provider can review it. The input is the generated menu data, and the output is the menu information displayed in the application.

[0982] In this way, the system performs a series of processes from user input, emotion recognition, menu generation, and output.

[0983] (Application example 1)

[0984] Next, a description will be given of Application Example 1 of Form 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".

[0985] Conventional menu generation systems can take into account school lunch rules and nutritional balance, but they cannot provide menus that reflect the user's emotional state. In addition, they lacked the functionality to link the generated menus to food delivery services, which resulted in low user convenience. This made it difficult to provide the optimal meal according to the user's emotions.

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

[0987] In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying a default school lunch rule, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means including an emotion engine for recognizing the emotional state of a user, a means for generating a menu based on the recognition result of the emotion engine, and a means for ordering the generated menu from a food delivery service. This makes it possible to generate a menu that takes into account the emotional state of the user, and further allows the generated menu to be ordered in conjunction with a food delivery service, improving user convenience.

[0988] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[0989] A "specified period" refers to a specific period set by the user, and serves as the basis for generating a menu within that period.

[0990] "School lunch rules" refer to regulations and guidelines regarding school lunches, and are the standards based on which menus are created.

[0991] A "budget" refers to the upper limit of expenses taken into consideration when creating a menu, and is a standard for setting economic constraints.

[0992] "Nutritional balance" refers to the distribution of nutrients necessary to provide a healthy diet, and is the standard for creating menus based on this.

[0993] "API-linked applications" refer to external software or services used to output the generated menus and recipes.

[0994] An "emotion engine" is a system for recognizing a user's emotional state from input information, identifying basic emotions such as joy, sadness, anger, and surprise.

[0995] "Food delivery service" refers to a service that delivers meals ordered by a user to a specified location.

[0996] A "menu" refers to a menu of meals to be served within a specific period of time, and is automatically created by generative AI.

[0997] A "recipe" refers to a document that lists the steps and ingredients for preparing a dish based on a menu.

[0998] The system for implementing the present invention includes a generative AI, an emotion engine, and an API for linking with a food delivery service. A specific embodiment of the system will be described below.

[0999] System Configuration

[1000] The system consists of the following main components:

[1001] 1. Generative AI: Artificial intelligence that automatically generates menus and recipes based on specified conditions.

[1002] 2. Emotion engine: A system that recognizes the user's emotional state from input information.

[1003] 3. Food delivery service API: An interface for connecting the generated menu to a food delivery service to place an order.

[1004] Hardware and software used

[1005] Hardware: Smartphones, servers

[1006] Software: Python, OpenAI API, Food Delivery Service API

[1007] Data processing and calculation

[1008] 1. Emotion recognition: The user inputs their emotional state through their smartphone. The emotion engine analyzes the user's input information (text, voice, images, etc.) and recognizes their emotional state. For example, emotions are analyzed using OpenAI's API.

[1009] 2. Menu Generation: Based on the recognition results of the emotion engine, the generation AI generates the optimal menu. The generation AI creates a menu taking into account the user's emotional state, school lunch rules, budget, nutritional balance, and other conditions.

[1010] 3. Order integration: The generated menu is ordered through the food delivery service API. This allows users to easily order the generated menu.

[1011] Examples

[1012] If a user types "I'm so happy today!" into their smartphone, the emotion engine recognizes this as "joy." The generative AI then suggests "luxurious dishes like sushi and steak" based on this emotional state. The suggested menu is then ordered through a food delivery service API and delivered to the user's designated location.

[1013] Examples of prompt statements

[1014] Prompt for the emotion recognition engine:

[1015] User Input: I'm so happy today!

[1016] Recognize the emotion.

[1017] Prompt to menu generation engine:

[1018] Emotion: Joy

[1019] Generate a menu based on this emotion.

[1020] In this way, it becomes possible to generate a menu that takes into account the user's emotional state, and the generated menu can be ordered in conjunction with a food delivery service, thereby improving user convenience.

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

[1022] Step 1:

[1023] The user inputs his / her emotional state via a smartphone.

[1024] Input: The user's emotional state (e.g., "I'm so happy today!")

[1025] Actions: A smartphone application receives user input.

[1026] Output: User's emotional state text data

[1027] Step 2:

[1028] The server uses an emotion engine to recognize the user's emotional state.

[1029] Input: User's emotional state text data

[1030] How it works: The emotion engine (OpenAI API) analyzes text data and recognizes emotions.

[1031] Output: The recognized emotion (e.g. "joy")

[1032] Step 3:

[1033] The server uses generative AI to generate menus based on the recognized emotions.

[1034] Input: Recognized emotions (e.g., "joy"), school lunch rules, budget, nutritional balance

[1035] How it works: The generative AI takes these conditions into account and generates an optimal menu.

[1036] Output: Generated menu (e.g. "Luxurious dishes including sushi and steak")

[1037] Step 4:

[1038] The server sends the generated menu to the food delivery service API.

[1039] Input: Generated menu

[1040] How it works: The server sends the menu data to the food delivery service API and places the order.

[1041] Output: Order confirmation data from a food delivery service

[1042] Step 5:

[1043] The user receives an order confirmation on their smartphone.

[1044] Input: Order confirmation data from food delivery service

[1045] How it works: The smartphone application receives the order confirmation data and notifies the user.

[1046] Output: Order confirmation notification to user

[1047] In this way, it becomes possible to generate a menu that takes into account the user's emotional state, and the generated menu can be ordered in conjunction with a food delivery service, thereby improving user convenience.

[1048] Example 2

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

[1050] In conventional school lunch systems, creating menus and adjusting nutritional balance are done manually, which takes time and effort. In addition, it is difficult to respond to individual needs because recipes cannot be adjusted according to the user's emotions. This makes it difficult for school lunch operators to provide menus efficiently and flexibly.

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

[1052] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying default school lunch rules, budget, nutritional balance, etc., a means for generating the menu and recipes, a means for outputting in an application linked with the API, a means for recognizing the user's emotions using an emotion engine, and a means for adjusting the recipe based on the user's emotions. This enables school lunch operators to efficiently create menus and flexibly adjust recipes according to the user's emotions.

[1053] "Generative AI" refers to artificial intelligence that automatically generates menus and recipes based on specified conditions.

[1054] A "designated period" refers to a specific period set aside for creating school lunch menus and recipes.

[1055] "School lunch rules" refer to regulations and guidelines regarding the provision of school lunches, including specific instructions such as "serve fish once a week."

[1056] A "budget" is the maximum amount that can be spent on each school lunch.

[1057] "Nutritional balance" refers to the balance of nutrients, such as the calories per meal and the ratio of protein, fat, and carbohydrates.

[1058] An "API-integrated application" is an external application that receives the generated menus and recipes and displays and manages them.

[1059] An "emotion engine" is a technology that analyzes a user's facial expressions and voice and recognizes their emotions.

[1060] The "means for adjusting a recipe based on a user's emotions" refers to a means for modifying or adjusting a recipe in accordance with the user's emotions based on the recognition results of the emotion engine.

[1061] The present invention is a system for automatically generating menus and recipes for school meal service providers to efficiently adjust the menus and recipes according to the user's emotions. A specific embodiment of the system will be described below.

[1062] Hardware and Software Used

[1063] Hardware: Servers, terminals

[1064] Software: Generative AI models, emotion engines, API-integrated applications

[1065] System Overview

[1066] This system uses a generative AI model to automatically generate menus and recipes for a specified period, and an emotion engine to adjust the recipes based on the user's emotions. The user uses a terminal to input school lunch rules, budget, and nutritional balance, and the server receives and processes this information.

[1067] Program Processing

[1068] 1. Information entered by the user

[1069] The user uses the terminal to enter the following information:

[1070] School lunch rules (e.g., serve fish once a week)

[1071] Budget (e.g. 500 yen per meal)

[1072] Nutritionally balanced (e.g. 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving)

[1073] 2. Processing generative AI models

[1074] The server receives the information entered by the user and sends it as a prompt to the generative AI model, which then automatically generates menus and recipes for the specified period based on this information.

[1075] 3. Output to API-linked applications

[1076] The server sends the menu and recipes received from the generative AI model to an API-linked application, allowing users to check the generated menu and recipes on their devices.

[1077] 4. Emotion engine processing

[1078] The emotion engine analyzes the user's facial expressions and voice to recognize the user's emotions. The server sends the emotion engine's recognition results to the generative AI model, which then adjusts the recipe based on the emotions.

[1079] 5. Output of adjusted recipe

[1080] The server receives the adjusted recipe from the generative AI model and sends it back to the API-linked application, allowing the user to check the adjusted recipe on their device.

[1081] Examples

[1082] Information entered by the user:

[1083] School lunch rule: Serve fish once a week

[1084] Price: 500 yen per meal

[1085] Nutritionally balanced: 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving

[1086] Output of the generative AI model:

[1087] Monday: Fish stew

[1088] Tuesday: Teriyaki Chicken

[1089] Sentiment engine recognition results:

[1090] The user is expressing happiness

[1091] Adjusted recipe:

[1092] Monday: Fish stew (user adds preferred recipe)

[1093] Tuesday: Teriyaki Chicken (users add their favorite recipes)

[1094] In this way, the system provides optimal menus and recipes based on the user's input information and emotions, enabling food service providers to create menus efficiently and flexibly adjust recipes according to the user's emotions.

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

[1096] Step 1:

[1097] The user uses a terminal to input school lunch rules, budget, and nutritional balance.

[1098] Specifically, the user enters information such as "provide fish once a week," "500 yen per meal," and "600 calories, 20g protein, 15g fat, and 70g carbohydrates per meal" into an input form on the terminal.

[1099] Input: School lunch rules, budget, nutritional balance

[1100] Output: The entered information is sent to the server.

[1101] Step 2:

[1102] The server receives information entered by the user and sends prompts to the generative AI model.

[1103] Specifically, the server converts the received information into a prompt sentence and sends it to the generative AI model. An example of a prompt sentence is as follows:

[1104] School lunch rule: Serve fish once a week

[1105] Price: 500 yen per meal

[1106] Nutritionally balanced: 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving

[1107] Input: Information entered by the user

[1108] Output: The prompt sent to the generative AI model

[1109] Step 3:

[1110] The generative AI model automatically generates menus and recipes for the specified period based on the prompt text.

[1111] Specifically, the generative AI model analyzes the prompt text and generates menus and recipes that fit the conditions. For example, it generates a weekly menu of simmered fish on Mondays and teriyaki chicken on Tuesdays.

[1112] Input: Prompt statement

[1113] Output: Generated menu and recipes

[1114] Step 4:

[1115] The server sends the generated menu and recipes to the API-integrated application.

[1116] Specifically, the server sends the menu and recipes received from the generative AI model to an API-linked application so that the user can view them on their device.

[1117] Input: Generated menu and recipe

[1118] Output: Menu and recipes sent to API-connected applications

[1119] Step 5:

[1120] The user reviews the generated menu and recipes and adjusts them as necessary.

[1121] Specifically, the user checks the menu and recipes displayed on the device and makes adjustments if certain ingredients are unavailable.

[1122] Input: Menu and recipe displayed in API-linked application

[1123] Output: Menu and recipes adjusted by the user

[1124] Step 6:

[1125] The emotion engine recognizes the user's emotions.

[1126] Specifically, the emotion engine analyzes the user's facial expressions and voice to recognize the user's emotions, for example, determining whether the user is expressing an emotion of joy or sadness.

[1127] Input: User's facial expressions and voice

[1128] Output: Perceived user emotion

[1129] Step 7:

[1130] The server sends the results of the emotion engine to the generative AI model.

[1131] Specifically, the server sends the emotion engine's recognition results to the generative AI model and requests it to adjust the recipe based on the user's emotion. For example, it sends information that "the user is expressing the emotion of joy."

[1132] Input: Emotion engine recognition results

[1133] Output: Emotion information sent to the generative AI model

[1134] Step 8:

[1135] A generative AI model adjusts recipes based on emotions.

[1136] Specifically, the generative AI model will adjust the recipe based on the results of the emotion engine: for example, if the user expresses happiness, it will incorporate cooking methods that the user would prefer into the recipe.

[1137] Input: Emotion information

[1138] Output: Adjusted recipe

[1139] Step 9:

[1140] The server resends the adjusted recipe to the API-connected application.

[1141] Specifically, the server receives the adjusted recipe from the generative AI model and sends it back to the API-linked application, allowing the user to check the adjusted recipe on their device.

[1142] Input: Adjusted recipe

[1143] Output: Recipe resubmitted to API-connected application

[1144] (Application example 2)

[1145] Next, a description will be given of Application Example 2 of Form 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".

[1146] Conventional school lunch systems have the problem that menus and nutritional balance adjustments are done manually, which takes time and effort. In addition, it is difficult to provide optimal meals for individual users because recipes cannot be adjusted to take into account the user's emotional state. Furthermore, food delivery services also have the problem of not being able to suggest menus that correspond to the user's preferences and emotions.

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

[1148] In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying a default school lunch rule, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means for analyzing a user's emotions using an emotion engine and adjusting a recipe based on the results, and a means including an application installed on a smartphone, smart glasses, a head-mounted display, or a robot. This makes it possible to propose optimal menus and recipes that take into account the user's emotional state.

[1149] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[1150] "Specified period" refers to a specific period set for generating menus and recipes.

[1151] "School lunch rules" refers to regulations and guidelines regarding the provision of school lunches, such as "serve fish once a week."

[1152] "Budget" refers to the upper limit of expenses taken into consideration when creating menus and recipes.

[1153] "Nutritional balance" refers to the ratio of calories, proteins, fats, carbohydrates, and other nutrients contained in a meal.

[1154] "API-linked applications" refer to external software or services used to output the generated menus and recipes.

[1155] An "emotion engine" refers to technology that analyzes the user's emotional state and adjusts recipes based on the results.

[1156] A "smartphone" refers to a mobile phone that can connect to the Internet and install applications.

[1157] "Smart glasses" refers to a glasses-type device that has the function of displaying information.

[1158] "Head-mounted display" refers to a display device that is worn on the head.

[1159] "Robot" refers to an automated machine that performs programmed actions.

[1160] The system for implementing the present invention includes a generative AI, an emotion engine, a smartphone, smart glasses, a head-mounted display, and a robot. Specific embodiments of the system are described below.

[1161] System Configuration

[1162] 1. Generation AI

[1163] The AI ​​automatically generates menus and recipes for a specified period based on the specified school lunch rules, budget, and nutritional balance. The AI ​​also suggests optimal menus based on the information entered by the user.

[1164] 2. Emotion Engine

[1165] The emotion engine analyzes the user's emotional state and provides the results to the generative AI. The emotion engine recognizes emotions from the user's facial expressions and voice, collecting data in real time.

[1166] 3. Smartphones, smart glasses, head-mounted displays, robots

[1167] These devices are used to display the generated menu and recipes to the user, who can then review the menu and make adjustments if necessary.

[1168] Program Processing

[1169] The server receives information on school lunch rules, budget, and nutritional balance entered by the user and sends it to the generation AI. The generation AI generates menus and recipes based on this information and makes adjustments taking into account the emotion data from the emotion engine. The generated menus and recipes are output to smartphones, smart glasses, head-mounted displays, and robots through API-linked applications.

[1170] Hardware and software used

[1171] Generation AI: OpenAI API

[1172] Emotion Engine: Emotion Engine API

[1173] Devices: Smartphones, smart glasses, head-mounted displays, robots

[1174] Examples

[1175] The user opens the smartphone app and enters the following information:

[1176] Budget: 1,000 yen

[1177] Nutritional balance: Calories 600kcal, Protein 20g, Fat 10g, Carbohydrates 50g

[1178] Allergies: Nuts

[1179] School lunch rule: serve fish once a week

[1180] If the emotion engine recognizes the user's emotion as "joy," the generative AI will receive the following prompt:

[1181] Examples of prompt statements

[1182] User Emotion: Delight

[1183] Price: 1000 yen

[1184] Nutritional balance: Calories 600kcal, Protein 20g, Fat 10g, Carbohydrates 50g

[1185] Allergies: Nuts

[1186] School lunch rules: serve fish once a week

[1187] Use this information to generate the best menus and recipes.

[1188] Based on these prompts, the AI ​​will generate menus and recipes and suggest them to the user. The user can then review the suggested menus via their smartphone, smart glasses, head-mounted display, or robot and make adjustments as necessary.

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

[1190] Step 1:

[1191] Users open the smartphone app and enter school lunch rules, budget, nutritional balance, and allergy information.

[1192] Input: User-entered school lunch rules, budget, nutritional balance, and allergy information

[1193] Output: The entered information is sent to the server.

[1194] Step 2:

[1195] The server receives the entered information and sends it to the generation AI.

[1196] Input: School lunch rules, budget, nutritional balance, allergy information sent by the user

[1197] Output: The prompt sent to the generation AI

[1198] Step 3:

[1199] The generative AI generates menus and recipes for the specified period based on the prompt text.

[1200] Input: Prompt statement

[1201] Output: Generated menu and recipes

[1202] Step 4:

[1203] The emotion engine analyzes the user's emotional state and sends the results to the server.

[1204] Input: User's facial expressions and voice data

[1205] Output: Parsed emotion data

[1206] Step 5:

[1207] The server receives the emotion data and sends it to the generation AI.

[1208] Input: Emotion data

[1209] Output: Emotion data sent to the generative AI

[1210] Step 6:

[1211] Generative AI adjusts menus and recipes based on emotional data.

[1212] Input: emotion data, generated menu and recipe

[1213] Output: Adjusted menu and recipes

[1214] Step 7:

[1215] The server sends the adjusted menu and recipes to the API-integrated application.

[1216] Input: Adjusted menu and recipe

[1217] Output: Data sent to the API-integrated application

[1218] Step 8:

[1219] Smartphones, smart glasses, head-mounted displays, and robots receive data from API-connected applications and display it to the user.

[1220] Input: Data received from the API-integrated application

[1221] Output: The menu and recipes displayed to the user

[1222] Step 9:

[1223] The user reviews the displayed menu and recipes and makes adjustments as necessary.

[1224] Input: Menu and recipes confirmed by the user

[1225] Output: Final, adjusted menu and recipe

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

[1227] 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> ) and other generation AIs. The data generation model 58 is obtained by making a neural network perform deep learning. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating a voice, text data indicating a text, and image data indicating an image is input. The data generation model 58 performs inference on the input inference data according to 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.

[1228] Another example of generative AI is Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) are mentioned.

[1229] 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 smart glasses 214.

[1230] [Third embodiment]

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

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

[1233] 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 wide area network (WAN) and / or a local area network (LAN).

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

[1235] 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 the voice according to instructions from the processor 46.

[1236] Camera 42 is a small digital camera equipped with an optical system including a lens, an aperture, and a 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 (e.g., an imaging range defined by an angle of view equivalent to the width of the field of vision of an average healthy person).

[1237] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for transmitting and receiving various types of information between the processor 46 and the processor 28 via the network 54. The transmission and reception of various types of information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is performed in a secure state.

[1238] Fig. 6 shows an example of 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.

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

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

[1241] In the headset type terminal 314, 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.

[1242] Next, the specific processing by the specific processing unit 290 of the data processing device 12 will be described.

[1243] "Example 1"

[1244] One embodiment of the present invention is a system that uses generation AI to automatically generate menus for a specified period. This system generates menus and recipes based on preset school lunch rules, budgets, nutritional balance, etc. The generated menus and recipes are output by an application linked to the API, and school lunch operators can use this to replace nutritionists with AI.

[1245] "Example 2"

[1246] As a specific example, consider the case where a school lunch provider uses this system. First, the school lunch provider specifies the school lunch rules (e.g., serving fish once a week), budget, and nutritional balance (e.g., calories per meal and the ratio of protein, fat, and carbohydrates) to the generation AI. Based on this information, the generation AI automatically generates menus and recipes for the specified period. The generated menus and recipes are output by an application linked to the API, and the school lunch provider can check them and make adjustments as necessary.

[1247] The process flow of each embodiment will be described below.

[1248] "Example 1"

[1249] Step 1: The school lunch provider specifies the default school lunch rules, budget, nutritional balance, etc. to the generation AI.

[1250] Step 2: The generation AI automatically generates menus and recipes for the specified period based on the specified information.

[1251] Step 3: The generated menu and recipes are output to the application that is linked to the API.

[1252] Step 4: The food service provider reviews the printed menu and recipes and makes adjustments as necessary.

[1253] "Example 2"

[1254] Step 1: The school lunch provider specifies the lunch rules (e.g., serving fish once a week), budget, and nutritional balance (e.g., calories per meal, and the ratio of protein, fat, and carbohydrates) to the generation AI.

[1255] Step 2: Based on this information, the generation AI automatically generates menus and recipes for the specified period.

[1256] Step 3: The generated menu and recipes are output to the application that is linked to the API.

[1257] Step 4: The food service provider reviews the printed menu and recipes and makes adjustments as necessary.

[1258] Example 1

[1259] Next, a description will be given of Example 1 of the embodiment 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".

[1260] Traditionally, school lunch menus were created manually by nutritionists, which took time and effort, and it was difficult to consider budgets and nutritional balance. In addition, specialized knowledge of nutritionists was required, and it is often difficult for school lunch operators to secure human resources. This has created a demand for efficient and effective menu creation.

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

[1262] In this invention, the server includes a means for the user to input conditions, a means for the server to receive the conditions, a means for the server to send a prompt to the generation AI model, a means for the generation AI model to generate a menu, a means for the server to send the generated menu to an API partner, and a means for the terminal to display the results. This allows the user to easily specify conditions and efficiently generate a menu.

[1263] The "means for the user to input conditions" is an interface that allows the user to input conditions such as school lunch rules, budget, and nutritional balance.

[1264] The "means for the server to receive the conditions" is a function that enables the server to receive and analyze the conditions sent from the user.

[1265] "Means for the server to send a prompt to the generative AI model" refers to a function for generating a prompt sentence based on the conditions received by the server and sending it to the generative AI model.

[1266] "Means for the generative AI model to generate a menu" refers to the function by which the generative AI model automatically creates a menu that meets the specified conditions based on the prompt text sent to it.

[1267] "Means for the server to send the generated menu to the API partner" refers to a function that enables the server to send the menu received from the generative AI model to the partner application via API.

[1268] "Means for the terminal to display the results" refers to a function for displaying the menu received from the API-connected application on the user's terminal.

[1269] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[1270] This invention is a system that uses a generative AI model to automatically generate a menu for a specified period. This system generates the menu and recipes based on the user's input of conditions such as school lunch rules, budget, and nutritional balance. The generated menu and recipes are output by an application linked to the API, and school lunch operators can use this to replace nutritionists with AI.

[1271] Hardware and Software Used

[1272] Hardware:

[1273] Terminal (the device through which the user enters the conditions, e.g. PC, tablet, smartphone)

[1274] Server (for data processing and running generative AI models)

[1275] software:

[1276] A web interface or dedicated application (an interface for users to enter conditions)

[1277] Server-side programs (e.g. Python's Flask framework)

[1278] Generative AI models (e.g. OpenAI's GPT-4)

[1279] API integration software (e.g. RESTful API)

[1280] Data processing and calculation

[1281] 1. The user enters the conditions

[1282] The user uses the terminal to input conditions such as school lunch rules, budget, nutritional balance, etc. For example, the user may input conditions such as "Create a menu for one week," "Budget per meal is within 500 yen," and "Calories are 600 kcal or less."

[1283] 2. The server receives the conditions

[1284] The conditions sent from the terminal are sent to the server as an HTTP request. The server receives the request and analyzes the conditions. For example, the server receives the request using the Python Flask framework.

[1285] 3. The server sends a prompt to the generative AI model

[1286] The server generates a prompt based on the received conditions and sends it to the generative AI model. For example, the prompt might be, "Please create a menu for one week. Please keep the budget per meal within 500 yen and calories below 600 kcal." The server sends this prompt to the generative AI model.

[1287] 4. A generative AI model generates menus

[1288] The generative AI model generates a menu based on the prompt sent in. For example, the generative AI model generates a menu such as "Monday: teriyaki chicken, spinach ohitashi, rice" or "Tuesday: grilled salmon, miso soup, salad."

[1289] 5. The server sends the generated menu to the API partner

[1290] The server sends the menu received from the generative AI model to the partner application via API. For example, the server sends data using a RESTful API. The partner application is a dedicated management system used by a food service provider.

[1291] 6. The device will display the results.

[1292] The terminal displays the menu received from the API-linked application. The user can check it and modify or regenerate it as necessary. For example, the user can send a request again such as "I want to change Monday's menu."

[1293] Examples

[1294] If a user enters the conditions "Create a menu for one week," "Budget per meal is less than 500 yen," and "Calories are less than 600 kcal," the system will generate a menu like the one below.

[1295] Monday: Teriyaki chicken, spinach salad, rice

[1296] Tuesday: Grilled salmon, miso soup, salad

[1297] Wednesday: Pork with ginger, shredded cabbage, rice

[1298] Thursday: Curry rice, salad

[1299] Friday: Hamburger steak, potato salad, rice

[1300] Example prompt:

[1301] "Please create a menu for one week. Please limit each meal to 500 yen or less and keep the calories to 600 kcal or less."

[1302] In this way, users can easily specify conditions and efficiently generate menus through the system.

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

[1304] Step 1:

[1305] The user enters the conditions

[1306] Specific operation: The user uses a dedicated application on the device or a web interface to input conditions such as school lunch rules, budget, and nutritional balance.

[1307] Input: School lunch rules, budget, nutritional balance, and other conditions

[1308] Output: The entered condition data

[1309] Data processing: Convert the conditions entered by the user into a data format such as JSON.

[1310] Step 2:

[1311] The server receives the conditions

[1312] Specific operation: The conditions sent from the terminal are sent to the server as an HTTP request. The server receives this request and analyzes the conditions.

[1313] Input: Condition data entered by the user

[1314] Output: Parsed condition data

[1315] Data processing: The server analyzes the received condition data and converts it into a format that can be used internally.

[1316] Step 3:

[1317] The server sends prompts to the generative AI model

[1318] Specific operation: The server generates a prompt sentence based on the received conditions and sends it to the generative AI model.

[1319] Input: Parsed condition data

[1320] Output: The prompt sent to the generative AI model

[1321] Data processing: The server generates prompt sentences based on the condition data and converts them into a format suitable for the generative AI model.

[1322] Step 4:

[1323] A generative AI model generates menus

[1324] How it works: The generative AI model generates a menu based on the prompt text sent.

[1325] Input: prompt statement

[1326] Output: Generated menu data

[1327] Data processing: The generative AI model analyzes the prompt text and generates a menu that meets the conditions.

[1328] Step 5:

[1329] The server sends the generated menu to the API partner.

[1330] Specific operation: The server sends the menu received from the generative AI model to the linked application via API.

[1331] Input: Generated menu data

[1332] Output: Menu data sent to API partner

[1333] Data processing: The server converts the generated menu data into a format that can be received by the API-integrated application.

[1334] Step 6:

[1335] The terminal displays the results

[1336] Specific operation: The device displays the menu received from the API-linked application. The user can review it and modify or regenerate it as necessary.

[1337] Input: Menu data received from API partner

[1338] Output: Menu data displayed on the terminal

[1339] Data processing: The terminal converts the received menu data into a format that is easy for the user to view and displays it.

[1340] (Application example 1)

[1341] Next, a description will be given of Application Example 1 of Form 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".

[1342] In conventional school lunch systems, nutritionists had to manually create menus and manage food ordering and delivery, which was time-consuming and labor-intensive. In addition, creating menus that take nutritional balance and budget into account required specialized knowledge, making it difficult to do efficiently. Furthermore, ordering food and tracking delivery status were also done manually, which made it prone to errors and delays.

[1343] 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. In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying predetermined school lunch rules, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means for acquiring user input, a means for automatically ordering ingredients based on the generated menu, and a means for tracking and notifying the delivery status in real time. This enables efficient menu creation that takes nutritional balance and budget into consideration, and allows for integrated management from ordering ingredients to delivery.

[1344] "Generative AI" is artificial intelligence that automatically generates data based on specified conditions.

[1345] "Specified Period" refers to a specific period set by the User.

[1346] A "menu" is a list of the meals served during a particular period of time.

[1347] "School lunch rules" refers to regulations and guidelines regarding the provision of school lunches.

[1348] A "budget" refers to the maximum cost for ingredients or services for a particular period of time.

[1349] "Nutritional balance" refers to the appropriate distribution of nutrients necessary to maintain health.

[1350] A "recipe" is a list of steps and ingredients for making a particular dish.

[1351] An "API-integrated application" is an application that has an interface for exchanging data with other software or services.

[1352] "User Input" refers to information or data provided by a user to a system.

[1353] "Means for automatically ordering ingredients" refers to a function for automatically ordering necessary ingredients based on the generated menu.

[1354] "Means of tracking and notifying delivery status in real time" refers to a function that monitors the delivery status of ordered ingredients in real time and notifies the user.

[1355] The system for implementing this invention utilizes a generative AI model to automatically generate a menu for a specified period. A specific embodiment of this system will be described below.

[1356] System Configuration

[1357] 1. Getting user input:

[1358] Users use a device such as a smartphone or tablet to enter information such as the specified period, budget, and nutritional balance.

[1359] Hardware used: Smartphone, tablet

[1360] Software used: Mobile application (iOS / Android)

[1361] 2. Invoke the generative AI model:

[1362] The server sends prompts to the generative AI model based on the user's input data and generates a menu for the specified period.

[1363] Software used: Generative AI models (e.g. OpenAI GPT-4)

[1364] Example prompt: "Please generate a menu for a 7-day period with a budget of 5,000 yen and a nutritional balance of high protein and low fat."

[1365] 3. Menu and recipe generation:

[1366] The server retrieves the menu and recipes returned by the generative AI model and displays them on the user's device.

[1367] Software used: Mobile application

[1368] 4. Automated food ordering:

[1369] The server then lists the ingredients needed based on the proposed menu and sends the order to a partner food delivery service.

[1370] Software used: API integration (e.g. food delivery service API)

[1371] 5. Tracking your delivery:

[1372] After the order is confirmed, the server tracks the delivery status in real time and notifies the user's terminal.

[1373] Software used: Mobile applications, notification systems (e.g. Firebase Cloud Messaging)

[1374] Examples

[1375] A user logs into the application using their smartphone and enters the following information:

[1376] Specified period: 7 days

[1377] Price: 5,000 yen

[1378] Nutritional balance: high protein, low fat

[1379] With this information, the server sends the following prompt to the generative AI model:

[1380] "Please create a menu for a specified period of 7 days, a budget of 5,000 yen, and a nutritionally balanced high protein, low fat menu."

[1381] The menu and recipes returned by the generative AI model are displayed on the user's smartphone. The user can review the suggested menu and the necessary ingredients are automatically ordered. Once the order is confirmed, the delivery status is tracked in real time and the user is notified.

[1382] In this way, users can easily create nutritionally balanced meal plans and manage everything from ordering ingredients to delivery all in one place.

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

[1384] Step 1:

[1385] A user uses a device such as a smartphone or tablet to input information such as a specified period, budget, and nutritional balance. The input information is sent from the device to a server. The input data includes a specified period (e.g., 7 days), budget (e.g., 5,000 yen), and nutritional balance (e.g., high protein, low fat).

[1386] Step 2:

[1387] The server receives the input data sent by the user, creates a prompt sentence, and sends it to the generative AI model. An example of a prompt sentence is, "Please generate a menu for the specified period of 7 days, the budget of 5,000 yen, and a nutritional balance of high protein and low fat." The server sends this prompt sentence to the generative AI model, instructing it to generate a menu for the specified period.

[1388] Step 3:

[1389] The generative AI model generates menus and recipes for the specified period based on the prompt text received from the server. The generative AI model analyzes the input data and generates the optimal menu taking into account the predefined school lunch rules, budget, and nutritional balance. The generated menus and recipes are returned to the server.

[1390] Step 4:

[1391] The server receives the menu and recipes returned from the generative AI model and transmits them to the user's terminal. The user's terminal displays the received menu and recipes. The user can confirm the suggested menu.

[1392] Step 5:

[1393] The server lists the ingredients required based on the proposed menu and sends an order to the partner food delivery service. The server sends the order data to the food delivery service using API integration. The order data includes the list and quantities of the ingredients required.

[1394] Step 6:

[1395] After the order is confirmed, the server tracks the delivery status in real time and notifies the user's terminal. The server receives delivery status data from the food delivery service and transmits it to the user's terminal. The user's terminal displays the delivery status in real time and notifies the user.

[1396] In this way, users can easily create nutritionally balanced meal plans and manage the entire process from ordering ingredients to delivery.

[1397] Example 2

[1398] Next, a second embodiment of the second form will be described. 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".

[1399] The traditional process of creating school lunch menus is time-consuming and labor-intensive, as it is done manually by nutritionists. In addition, creating menus while taking into account nutritional balance and budgets is complicated, making it difficult to operate efficiently. Furthermore, the specialized knowledge of nutritionists is required, making it difficult to secure human resources. There is a demand for a system that can solve these problems and create school lunch menus efficiently and automatically.

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

[1401] In this invention, the server includes a means for a user to access the system, a means for a user to input school lunch rules, a budget, and nutritional balance, a means for the server to receive the input data and generate a prompt sentence for the generative AI model, a means for the server to send the prompt sentence to the generative AI model, a means for the generative AI model to generate a menu and recipes, a means for the server to send the generated menu and recipes to an application via an API, a means for the terminal to display the menu and recipes through the application, and a means for the user to check the menu and recipes and adjust them as necessary. This makes it possible to automate and streamline the creation of school lunch menus.

[1402] A "user" is a person or organization that accesses the system and inputs information such as school lunch rules, budget, and nutritional balance.

[1403] A "server" is a computer system that receives input data from a user, generates prompt sentences, and sends them to the generative AI model.

[1404] A "generative AI model" is an artificial intelligence model that automatically generates menus and recipes based on user input data.

[1405] A "prompt sentence" is text-based input data that provides instructions to a generative AI model.

[1406] An "API" is an interface for exchanging data between different software applications.

[1407] An "application" is a software program that a user accesses through a terminal and that displays the generated menus and recipes.

[1408] A "terminal" is a device (such as a PC, tablet, or smartphone) that a user uses to access the system.

[1409] A "menu" is a plan of meals to be served for a particular period of time.

[1410] A "recipe" is a list of specific steps and ingredients for cooking a meal based on a menu.

[1411] "School lunch rules" are specific conditions or standards regarding the provision of school lunches (e.g., serving fish once a week).

[1412] A "budget" is the maximum amount that can be spent on each school lunch meal.

[1413] "Nutritional balance" is a standard regarding the nutritional value of a meal, such as the calories per meal and the ratio of protein, fat, and carbohydrates.

[1414] This invention is a system for efficiently creating menus and recipes for school meal service providers. The system automatically generates menus and recipes using a generative AI model after the user inputs school meal rules, budget, and nutritional balance. A specific embodiment of this system is described below.

[1415] A user accesses the system's web application using a terminal (PC, tablet, smartphone, etc.). The user enters authentication information on the login screen and logs into the system. After logging in, the user moves to the dashboard screen and clicks the "Create a new menu" button. In the input form that is displayed, the user enters school lunch rules (e.g., provide fish once a week), budget (e.g., no more than 500 yen per meal), and nutritional balance (e.g., 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal), and clicks the "Submit" button.

[1416] The server receives the data entered by the user and generates a prompt to be sent to the generative AI model based on the data. The prompt is a text that specifically describes the user's requirements. For example, the following prompt is generated:

[1417] Example prompt:

[1418] Create a school lunch menu for the week. The following conditions must be met:

[1419] Serve fish once a week

[1420] Budget is under 500 yen per meal

[1421] The nutritional balance is 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal.

[1422] The server sends the generated prompt to the generative AI model, which is an advanced natural language processing model such as OpenAI's GPT-3. The generative AI model automatically generates menus and recipes for the specified period based on the received prompt. The generated menus and recipes are returned to the server in text format.

[1423] The server receives the menu and recipes returned from the generative AI model and sends them to the linked application via API. The API uses, for example, a RESTful API. The application on the terminal displays the menu and recipes received from the server on the user interface. The user can visually check this.

[1424] The user can review the displayed menu and recipe and make adjustments as necessary, such as changing certain ingredients or adjusting portion sizes. Once adjustments are complete, the user can save the final menu and recipe.

[1425] This system allows school meal operators to create menus and recipes efficiently and automatically, significantly reducing time and labor. It also makes it easier to create menus that take into account nutritional balance and budgets, allowing them to provide high-quality school meals even without specialized knowledge.

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

[1427] Step 1:

[1428] A user accesses the system.

[1429] Input: A user uses a terminal to access the system's web application and enters login information.

[1430] Output: The user logs into the system and navigates to the dashboard screen.

[1431] Specific operations: A user opens a browser, enters the system URL, and accesses the system. On the login screen, the user enters the "user name" and "password," and clicks the "Login" button.

[1432] Step 2:

[1433] The user inputs school lunch rules, budget, and nutritional balance.

[1434] Input: The user clicks the "Create a new menu" button on the dashboard screen and enters school lunch rules, budget, and nutritional balance in the input form that appears.

[1435] Output: The data entered by the user is sent to the server.

[1436] Specific actions: The user clicks the "Create a new menu" button, enters the following into the input form that appears: "Provide fish once a week," "Budget is 500 yen or less per meal," "Calories 600 kcal, protein 20 g, fat 15 g, carbohydrates 80 g," and clicks the "Submit" button.

[1437] Step 3:

[1438] The server receives the input data and generates a prompt for the generative AI model.

[1439] Input: User-entered school lunch rules, budget, and nutritional balance data.

[1440] Output: The prompt to send to the generative AI model.

[1441] Specific operation: The server receives the user's input data and generates a prompt sentence saying, "Please create a school lunch menu for one week. The following conditions must be met: fish must be provided once a week, the budget must be within 500 yen per meal, and the nutritional balance must be 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal."

[1442] Step 4:

[1443] The server sends a prompt to the generative AI model.

[1444] Input: The generated prompt statement.

[1445] Output: The prompt is sent to the generative AI model.

[1446] Specific operation: The server sends the generated prompt text to the generative AI model.

[1447] Step 5:

[1448] A generative AI model generates menus and recipes.

[1449] Input: The prompt text sent by the server.

[1450] Output: Generated menu and recipes.

[1451] Specific operation: Based on the prompt, the generative AI model generates a menu and recipe, such as "Monday: grilled fish set meal, Tuesday: chicken curry, ...", and returns it to the server.

[1452] Step 6:

[1453] The server sends the generated menu and recipes to the application via an API.

[1454] Input: Meal plans and recipes returned by a generative AI model.

[1455] Output: The menu and recipes sent to the application.

[1456] Specific operation: The server receives the generated menu and recipes and sends them to the linked application via API.

[1457] Step 7:

[1458] The device displays menus and recipes through the application.

[1459] Input: Menu and recipes sent from the server.

[1460] Output: The menu and recipe displayed in a user interface.

[1461] Specific operation: The application on the device displays a menu and recipes such as "Monday: Grilled fish set meal, Tuesday: Chicken curry, ..."

[1462] Step 8:

[1463] User reviews menu and recipes and adjusts as needed.

[1464] Input: Displayed menu and recipe.

[1465] Output: Final, adjusted menu and recipes.

[1466] Specific actions: The user checks the displayed menu and recipes, makes adjustments such as "changing Tuesday's chicken curry to beef curry," and clicks the "Save" button.

[1467] (Application example 2)

[1468] Next, a description will be given of Application Example 2 of Form 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".

[1469] In conventional school lunch businesses and meal provision services, planning menus and managing nutritional balance was time-consuming and required specialized nutritionists. In addition, in order to meet the diverse needs of users, it was necessary to take into account individual dietary rules, budgets, and nutritional balance, which also placed a heavy burden on the users. There is a demand for a system that can solve these problems and generate and manage menus efficiently and flexibly.

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

[1471] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying predetermined dietary rules, budget, nutritional balance, etc., a means for generating the menu and recipes, a means for outputting in an application linked with the API, a means for generating the menu and recipes based on the dietary rules, budget, and nutritional balance specified by the user, and a means for confirming and adjusting the generated menu and recipes in a smartphone application. This enables the user to easily plan a nutritionally balanced menu and use a food delivery service.

[1472] "Generative AI" is artificial intelligence that automatically generates data based on specified rules and conditions.

[1473] A "menu" is a list of the meals served during a particular period of time.

[1474] A "recipe" is a detailed description of the steps and ingredients for making a particular dish.

[1475] A "dietary rule" refers to a specific condition or restriction regarding food, such as the use of a specific food ingredient once a week.

[1476] "Budget" refers to the financial constraints available for a specific period or conditions.

[1477] "Nutritional balance" refers to the appropriate proportions and amounts of nutrients contained in a meal.

[1478] An "API-integrated application" is an application that has an interface for exchanging data with other systems or services.

[1479] A "smartphone application" is a software program that runs on a smartphone.

[1480] "User" refers to any individual or organization that uses this system.

[1481] A "food delivery service" is a service that delivers meals ordered by a user to a specified location.

[1482] A system for implementing this invention includes means for automatically generating a menu for a specified period using generation AI, means for specifying pre-defined dietary rules, budget, nutritional balance, etc., means for generating menus and recipes, means for outputting in an application that is linked to the API, means for generating menus and recipes based on dietary rules, budget, and nutritional balance specified by the user, and means for checking and adjusting the generated menus and recipes within a smartphone application.

[1483] The server uses the generative AI model to generate menus and recipes based on the user's specified dietary rules, budget, and nutritional balance. Specifically, the generative AI model creates prompts based on information entered by the user through the smartphone application, and generates menus and recipes using the OpenAI API. The generated menus and recipes can be viewed within the smartphone application, and the user can make adjustments as necessary.

[1484] The hardware used is a smartphone, and the software is Python and OpenAI API. Data processing involves converting the dietary rules, budget, and nutritional balance entered by the user into prompt text and sending it to the generative AI model. Data calculation involves the generative AI model generating menus and recipes based on the prompt text.

[1485] As a specific example, if a user enters the conditions "include vegetarian menu once a week," "less than 500 yen per meal," and "600 calories, 20g protein, 10g fat, 80g carbohydrates per meal," the generation AI will generate a week's worth of menus and recipes that meet these conditions.

[1486] An example of a prompt is:

[1487] Menu rule: Include vegetarian menu once a week

[1488] Budget: Less than 500 yen per meal

[1489] Nutritionally balanced: 600 calories, 20g protein, 10g fat, 80g carbohydrates per serving

[1490] Use this information to generate a week's worth of menus and recipes.

[1491] In this way, users can easily plan nutritionally balanced meals and use food delivery services.

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

[1493] Step 1:

[1494] The user launches the smartphone application and inputs information such as dietary rules, budget, and nutritional balance.

[1495] Input: User-specified dietary rules, budget, nutritional balance

[1496] Output: Condition data entered

[1497] Specific operation: The user enters conditions into the application's input form and presses the submit button.

[1498] Step 2:

[1499] The terminal transmits the input condition data to the server.

[1500] Input: Criteria data entered by the user

[1501] Output: Condition data sent to the server

[1502] Specific operation: The smartphone application makes an API request to send condition data to the server.

[1503] Step 3:

[1504] The server generates a prompt sentence based on the received condition data.

[1505] Input: Condition data sent to the server

[1506] Output: Generated prompt statement

[1507] Specific operation: The server parses the condition data and embeds the data into a template for generating a prompt sentence.

[1508] Step 4:

[1509] The server sends the generated prompt text to the OpenAI API to generate a menu and recipe.

[1510] Input: Generated prompt text

[1511] Output: Generated menu and recipe data

[1512] Specific operation: The server sends a prompt to the OpenAI API, and the generative AI model generates a menu and recipe.

[1513] Step 5:

[1514] The server transmits the generated menu and recipe data to the smartphone application.

[1515] Input: Generated menu and recipe data

[1516] Output: Menu and recipe data sent to the smartphone application

[1517] Specific operation: The server performs an API response to return the generated data to the smartphone application.

[1518] Step 6:

[1519] The terminal displays the received menu and recipe data, and the user can check and adjust it.

[1520] Input: Menu and recipe data sent to the smartphone application

[1521] Output: Menu and recipe data confirmed and adjusted by the user

[1522] Specific operation: The smartphone application displays the received data on the screen and provides an interface for the user to make adjustments as necessary.

[1523] In addition, 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.

[1524] "Example 1"

[1525] As one embodiment of the present invention, a system incorporating an emotion engine is provided. In this system, the generation AI includes an emotion engine that recognizes the user's emotion. Specifically, the generation AI recognizes the user's emotional state from information such as text, voice, and images input by the user to the system. This emotion engine can recognize the user's basic emotions, such as joy, sadness, anger, and surprise. Based on the recognition results, the generation AI automatically generates a menu. For example, if the user expresses joy, the generation AI incorporates ingredients and dishes that the user would like into the menu. Also, if the user expresses sadness, the generation AI incorporates ingredients and dishes that would cheer up the user into the menu. In this way, it is possible to generate a menu that takes into account the user's emotional state.

[1526] "Example 2"

[1527] Furthermore, as another embodiment of the present invention, a system is provided in which an emotion engine adjusts a recipe based on the emotion of a user. Specifically, the generation AI adjusts the recipe based on the recognition result of the emotion engine. For example, if a user shows an emotion of joy, the generation AI incorporates a recipe that the user would like into the recipe. Also, if a user shows an emotion of sadness, the generation AI incorporates a recipe that would cheer up the user. In this way, it is possible to adjust the recipe taking into account the emotional state of the user.

[1528] The process flow of each embodiment will be described below.

[1529] "Example 1"

[1530] Step 1: The user inputs information into the system. This information can be in various forms, such as text, audio, or images.

[1531] Step 2: The emotion engine recognizes the user's emotional state from the input information. This emotion engine has the ability to recognize basic emotions such as happiness, sadness, anger, and surprise.

[1532] Step 3: The generation AI automatically generates a menu based on the recognition results of the emotion engine. Depending on the user's emotional state, the generation AI selects ingredients and dishes to be included in the menu.

[1533] "Example 2"

[1534] Step 1: The user inputs information into the system. This information can be in various forms, such as text, audio, or images.

[1535] Step 2: The emotion engine recognizes the user's emotional state from the input information. This emotion engine has the ability to recognize basic emotions such as happiness, sadness, anger, and surprise.

[1536] Step 3: The generative AI adjusts the recipe based on the recognition results of the emotion engine. Depending on the user's emotional state, the generative AI selects the cooking methods to incorporate into the recipe.

[1537] Example 1

[1538] Next, a description will be given of Example 1 of the embodiment 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".

[1539] Conventional school lunch menu generation systems have the problem that it takes time and effort for nutritionists to create menus manually. In addition, it is not possible to generate menus that take into account the emotional state of the user, making it difficult to provide menus that meet the needs of individual users. Furthermore, there was a demand for a system that would allow school lunch operators to replace nutritionists with AI.

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

[1541] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying default school lunch rules, budget, nutritional balance, etc., a means for recognizing emotions from user input information, a means for generating a menu and recipes based on the recognized emotions, and a means for outputting in an application linked to the API. This makes it possible to generate a menu that takes into account the emotional state of the user, and provides a system that allows school lunch operators to replace nutritionists with AI.

[1542] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[1543] The "specified period" refers to a specific period set by the user, and serves as the basis for generating a menu within that period.

[1544] "School lunch rules" refer to the regulations and guidelines regarding the provision of school lunches, based on which the menu is generated.

[1545] A "budget" refers to the upper limit of costs that are taken into consideration when generating a menu, and serves as a standard for creating a menu within a specified amount.

[1546] "Nutritional balance" refers to the distribution of nutrients necessary to provide a healthy meal, and menus are created based on this.

[1547] "Means for recognizing emotions" refers to technology that analyzes and recognizes a user's emotional state from input information (text, voice, images, etc.).

[1548] An "API-integrated application" refers to software that interacts with the server to receive and display the generated menus and recipes.

[1549] A "nutritionist" is a professional who creates menus taking into account the nutritional balance of meals, and in this invention, the generative AI takes on that role.

[1550] This invention is a system that uses generation AI to automatically generate menus for a specified period. The system generates menus and recipes based on conditions such as school lunch rules, budgets, and nutritional balance. The generated menus and recipes are output to an application linked with the API and can be used by school lunch providers.

[1551] Hardware and Software Used

[1552] Hardware: Servers, terminals (PCs, smartphones)

[1553] Software: Generative AI models (e.g. GPT-4), emotion engines (e.g. IBM Watson Tone Analyzer), API-integrated applications

[1554] Explanation of program processing

[1555] User Input

[1556] The user uses a terminal to input conditions such as school lunch rules, budget, nutritional balance, etc. into the system. For example, the user might input, "Generate a menu for one week. The budget is 500 yen per day, and the nutritional balance is more vitamin C."

[1557] Emotion recognition by emotion engine

[1558] The server receives information such as text, voice, and images entered by the user and uses an emotion engine to recognize the user's emotional state. For example, if a user enters "I've been tired lately," the emotion engine recognizes the "feeling of fatigue."

[1559] Menu generation by generative AI

[1560] The server uses the generative AI model to generate menus and recipes based on the emotion engine's recognition results and the conditions specified by the user. For example, if the user expresses fatigue, the generative AI generates a menu using ingredients rich in vitamin C. Specifically, the generative AI model is input with the following prompt sentence:

[1561] "The user is tired, so please generate a week's worth of meals using ingredients rich in Vitamin C. The budget is 500 yen per day."

[1562] Output via API integration

[1563] The server outputs the generated menu and recipes to the linked application via the API. For example, the menu is displayed in an application used by a food service provider. Specifically, the server sends the generated data to the API endpoint via a POST request.

[1564] Examples

[1565] User input:

[1566] The user enters on the terminal, "Please generate a menu for one week. The budget is 500 yen per day, and the nutritional balance is more vitamin C" and clicks the send button.

[1567] Emotion Recognition with Emotion Engine:

[1568] The server receives the user's input and sends the text data to the emotion engine.

[1569] The emotion engine recognizes "fatigue" and returns the result to the server.

[1570] Menu generation by generative AI:

[1571] The server sends a prompt to the generative AI model based on the results of the emotion engine and the user's conditions.

[1572] The generative AI model generates the menu and returns the results to the server.

[1573] Output via API integration:

[1574] The server sends the generated menu data to the API endpoint via a POST request.

[1575] The application displays the received data so that the food service provider can review it.

[1576] In this way, the system performs a series of processes from user input, emotion recognition, menu generation, and output.

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

[1578] Step 1:

[1579] The user inputs the conditions.

[1580] The user uses a terminal to input conditions such as school lunch rules, budget, and nutritional balance into the system. For example, the user might input, "Generate a one-week menu. The budget is 500 yen per day, and the nutritional balance is more vitamin C," and then click the send button. The input data is sent to the server.

[1581] Step 2:

[1582] The server recognizes the user's emotions using an emotion engine.

[1583] The server receives text data entered by the user and sends it to the emotion engine. The emotion engine analyzes the text data and recognizes the user's emotional state. For example, in response to the input "I've been tired lately," the emotion engine recognizes "feeling tired" and returns the result to the server. The input is the user's text data, and the output is the recognized emotion data.

[1584] Step 3:

[1585] The server generates the menu using a generative AI model.

[1586] The server sends a prompt to the generative AI model based on the emotion engine's recognition results and the conditions specified by the user. For example, a prompt such as "The user is tired, so please generate a week's menu using ingredients rich in vitamin C. The budget is 500 yen per day" is sent to the generative AI model. The generative AI model generates menus and recipes based on this prompt and returns the results to the server. The input is the prompt, and the output is the generated menu data.

[1587] Step 4:

[1588] The server outputs the generated menu to the application via API.

[1589] The server sends the generated menu and recipe data to the API endpoint via a POST request. The API-integrated application displays the received data so that the food service provider can review it. The input is the generated menu data, and the output is the menu information displayed in the application.

[1590] In this way, the system performs a series of processes from user input, emotion recognition, menu generation, and output.

[1591] (Application example 1)

[1592] Next, a description will be given of Application Example 1 of Form 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".

[1593] Conventional menu generation systems can take into account school lunch rules and nutritional balance, but they cannot provide menus that reflect the user's emotional state. In addition, they lacked the functionality to link the generated menus to food delivery services, which resulted in low user convenience. This made it difficult to provide the optimal meal according to the user's emotions.

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

[1595] In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying a default school lunch rule, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means including an emotion engine for recognizing the emotional state of a user, a means for generating a menu based on the recognition result of the emotion engine, and a means for ordering the generated menu from a food delivery service. This makes it possible to generate a menu that takes into account the emotional state of the user, and further allows the generated menu to be ordered in conjunction with a food delivery service, improving user convenience.

[1596] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[1597] A "specified period" refers to a specific period set by the user, and serves as the basis for generating a menu within that period.

[1598] "School lunch rules" refer to regulations and guidelines regarding school lunches, and are the standards based on which menus are created.

[1599] A "budget" refers to the upper limit of expenses taken into consideration when creating a menu, and is a standard for setting economic constraints.

[1600] "Nutritional balance" refers to the distribution of nutrients necessary to provide a healthy diet, and is the standard for creating menus based on this.

[1601] "API-linked applications" refer to external software or services used to output the generated menus and recipes.

[1602] An "emotion engine" is a system for recognizing a user's emotional state from input information, and identifies basic emotions such as joy, sadness, anger, and surprise.

[1603] "Food delivery service" refers to a service that delivers meals ordered by a user to a specified location.

[1604] A "menu" refers to a menu of meals to be served within a specific period of time, and is automatically created by generative AI.

[1605] A "recipe" refers to a document that lists the steps and ingredients for preparing a dish based on a menu.

[1606] The system for implementing the present invention includes a generative AI, an emotion engine, and an API for linking with a food delivery service. A specific embodiment of the system will be described below.

[1607] System Configuration

[1608] The system consists of the following main components:

[1609] 1. Generative AI: Artificial intelligence that automatically generates menus and recipes based on specified conditions.

[1610] 2. Emotion engine: A system that recognizes the user's emotional state from input information.

[1611] 3. Food delivery service API: An interface for connecting the generated menu to a food delivery service to place an order.

[1612] Hardware and software used

[1613] Hardware: Smartphones, servers

[1614] Software: Python, OpenAI API, Food Delivery Service API

[1615] Data processing and calculation

[1616] 1. Emotion recognition: The user inputs their emotional state through their smartphone. The emotion engine analyzes the user's input information (text, voice, images, etc.) and recognizes their emotional state. For example, emotions are analyzed using OpenAI's API.

[1617] 2. Menu Generation: Based on the recognition results of the emotion engine, the generation AI generates the optimal menu. The generation AI creates a menu taking into account the user's emotional state, school lunch rules, budget, nutritional balance, and other conditions.

[1618] 3. Order integration: The generated menu is ordered through the food delivery service API. This allows users to easily order the generated menu.

[1619] Examples

[1620] If a user types "I'm so happy today!" into their smartphone, the emotion engine recognizes this as "joy." The generative AI then suggests "luxurious dishes like sushi and steak" based on this emotional state. The suggested menu is then ordered through a food delivery service API and delivered to the user's designated location.

[1621] Examples of prompt statements

[1622] Prompt for the emotion recognition engine:

[1623] User Input: I'm so happy today!

[1624] Recognize the emotion.

[1625] Prompt to menu generation engine:

[1626] Emotion: Joy

[1627] Generate a menu based on this emotion.

[1628] In this way, it becomes possible to generate a menu that takes into account the user's emotional state, and the generated menu can be ordered in conjunction with a food delivery service, thereby improving user convenience.

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

[1630] Step 1:

[1631] The user inputs his / her emotional state via a smartphone.

[1632] Input: The user's emotional state (e.g., "I'm so happy today!")

[1633] Actions: A smartphone application receives user input.

[1634] Output: User's emotional state text data

[1635] Step 2:

[1636] The server uses an emotion engine to recognize the user's emotional state.

[1637] Input: User's emotional state text data

[1638] How it works: The emotion engine (OpenAI API) analyzes text data and recognizes emotions.

[1639] Output: The recognized emotion (e.g. "joy")

[1640] Step 3:

[1641] The server uses generative AI to generate menus based on the recognized emotions.

[1642] Input: Recognized emotions (e.g., "joy"), school lunch rules, budget, nutritional balance

[1643] How it works: The generative AI takes these conditions into account and generates an optimal menu.

[1644] Output: Generated menu (e.g. "Luxurious dishes including sushi and steak")

[1645] Step 4:

[1646] The server sends the generated menu to the food delivery service API.

[1647] Input: Generated menu

[1648] How it works: The server sends the menu data to the food delivery service API and places the order.

[1649] Output: Order confirmation data from a food delivery service

[1650] Step 5:

[1651] The user receives an order confirmation on their smartphone.

[1652] Input: Order confirmation data from food delivery service

[1653] How it works: The smartphone application receives the order confirmation data and notifies the user.

[1654] Output: Order confirmation notification to user

[1655] In this way, it becomes possible to generate a menu that takes into account the user's emotional state, and the generated menu can be ordered in conjunction with a food delivery service, thereby improving user convenience.

[1656] Example 2

[1657] Next, a second embodiment of the second form will be described. 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".

[1658] In conventional school lunch systems, creating menus and adjusting nutritional balance are done manually, which takes time and effort. In addition, it is difficult to respond to individual needs because recipes cannot be adjusted according to the user's emotions. This makes it difficult for school lunch operators to provide menus efficiently and flexibly.

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

[1660] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying default school lunch rules, budget, nutritional balance, etc., a means for generating the menu and recipes, a means for outputting in an application linked with the API, a means for recognizing the user's emotions using an emotion engine, and a means for adjusting the recipe based on the user's emotions. This enables school lunch operators to efficiently create menus and flexibly adjust recipes according to the user's emotions.

[1661] "Generative AI" refers to artificial intelligence that automatically generates menus and recipes based on specified conditions.

[1662] A "designated period" refers to a specific period set aside for creating school lunch menus and recipes.

[1663] "School lunch rules" refer to regulations and guidelines regarding the provision of school lunches, including specific instructions such as "serve fish once a week."

[1664] A "budget" is the maximum amount that can be spent on each school lunch.

[1665] "Nutritional balance" refers to the balance of nutrients, such as the calories per meal and the ratio of protein, fat, and carbohydrates.

[1666] An "API-integrated application" is an external application that receives the generated menus and recipes and displays and manages them.

[1667] An "emotion engine" is a technology that analyzes a user's facial expressions and voice and recognizes their emotions.

[1668] The "means for adjusting a recipe based on a user's emotions" refers to a means for modifying or adjusting a recipe in accordance with the user's emotions based on the recognition results of the emotion engine.

[1669] The present invention is a system for automatically generating menus and recipes for school meal service providers to efficiently adjust the menus and recipes according to the user's emotions. A specific embodiment of the system will be described below.

[1670] Hardware and Software Used

[1671] Hardware: Servers, terminals

[1672] Software: Generative AI models, emotion engines, API-integrated applications

[1673] System Overview

[1674] This system uses a generative AI model to automatically generate menus and recipes for a specified period, and an emotion engine to adjust the recipes based on the user's emotions. The user uses a terminal to input school lunch rules, budget, and nutritional balance, and the server receives and processes this information.

[1675] Program Processing

[1676] 1. Information entered by the user

[1677] The user uses the terminal to enter the following information:

[1678] School lunch rules (e.g., serve fish once a week)

[1679] Budget (e.g. 500 yen per meal)

[1680] Nutritionally balanced (e.g. 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving)

[1681] 2. Processing generative AI models

[1682] The server receives the information entered by the user and sends it as a prompt to the generative AI model, which then automatically generates menus and recipes for the specified period based on this information.

[1683] 3. Output to API-linked applications

[1684] The server sends the menu and recipes received from the generative AI model to an API-linked application, allowing users to check the generated menu and recipes on their devices.

[1685] 4. Emotion engine processing

[1686] The emotion engine analyzes the user's facial expressions and voice to recognize the user's emotions. The server sends the emotion engine's recognition results to the generative AI model, which then adjusts the recipe based on the emotions.

[1687] 5. Output of adjusted recipe

[1688] The server receives the adjusted recipe from the generative AI model and sends it back to the API-linked application, allowing the user to check the adjusted recipe on their device.

[1689] Examples

[1690] Information entered by the user:

[1691] School lunch rule: Serve fish once a week

[1692] Price: 500 yen per meal

[1693] Nutritionally balanced: 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving

[1694] Output of the generative AI model:

[1695] Monday: Fish stew

[1696] Tuesday: Teriyaki Chicken

[1697] Sentiment engine recognition results:

[1698] The user is expressing happiness

[1699] Adjusted recipe:

[1700] Monday: Fish stew (user adds preferred recipe)

[1701] Tuesday: Teriyaki Chicken (users add their favorite recipes)

[1702] In this way, the system provides optimal menus and recipes based on the user's input information and emotions, enabling food service providers to create menus efficiently and flexibly adjust recipes according to the user's emotions.

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

[1704] Step 1:

[1705] The user uses a terminal to input school lunch rules, budget, and nutritional balance.

[1706] Specifically, the user enters information such as "provide fish once a week," "500 yen per meal," and "600 calories, 20g protein, 15g fat, and 70g carbohydrates per meal" into an input form on the terminal.

[1707] Input: School lunch rules, budget, nutritional balance

[1708] Output: The entered information is sent to the server.

[1709] Step 2:

[1710] The server receives information entered by the user and sends prompts to the generative AI model.

[1711] Specifically, the server converts the received information into a prompt sentence and sends it to the generative AI model. An example of a prompt sentence is as follows:

[1712] School lunch rule: Serve fish once a week

[1713] Price: 500 yen per meal

[1714] Nutritionally balanced: 600 calories, 20g protein, 15g fat, 70g carbohydrates per serving

[1715] Input: Information entered by the user

[1716] Output: The prompt sent to the generative AI model

[1717] Step 3:

[1718] The generative AI model automatically generates menus and recipes for the specified period based on the prompt text.

[1719] Specifically, the generative AI model analyzes the prompt text and generates menus and recipes that fit the conditions. For example, it generates a weekly menu of simmered fish on Mondays and teriyaki chicken on Tuesdays.

[1720] Input: Prompt statement

[1721] Output: Generated menu and recipes

[1722] Step 4:

[1723] The server sends the generated menu and recipes to the API-integrated application.

[1724] Specifically, the server sends the menu and recipes received from the generative AI model to an API-linked application so that the user can view them on their device.

[1725] Input: Generated menu and recipe

[1726] Output: Menu and recipes sent to API-connected applications

[1727] Step 5:

[1728] The user reviews the generated menu and recipes and adjusts them as necessary.

[1729] Specifically, the user checks the menu and recipes displayed on the device and makes adjustments if certain ingredients are unavailable.

[1730] Input: Menu and recipe displayed in API-linked application

[1731] Output: Menu and recipes adjusted by the user

[1732] Step 6:

[1733] The emotion engine recognizes the user's emotions.

[1734] Specifically, the emotion engine analyzes the user's facial expressions and voice to recognize the user's emotions, for example, determining whether the user is expressing an emotion of joy or sadness.

[1735] Input: User's facial expressions and voice

[1736] Output: Perceived user emotion

[1737] Step 7:

[1738] The server sends the results of the emotion engine to the generative AI model.

[1739] Specifically, the server sends the emotion engine's recognition results to the generative AI model and requests it to adjust the recipe based on the user's emotion. For example, it sends information that "the user is expressing the emotion of joy."

[1740] Input: Recognition results of emotion engine

[1741] Output: Emotion information sent to the generative AI model

[1742] Step 8:

[1743] A generative AI model adjusts recipes based on emotions.

[1744] Specifically, the generative AI model will adjust the recipe based on the results of the emotion engine: for example, if the user expresses happiness, it will incorporate cooking methods that the user would prefer into the recipe.

[1745] Input: Emotion information

[1746] Output: Adjusted recipe

[1747] Step 9:

[1748] The server resends the adjusted recipe to the API-connected application.

[1749] Specifically, the server receives the adjusted recipe from the generative AI model and sends it back to the API-linked application, allowing the user to check the adjusted recipe on their device.

[1750] Input: Adjusted recipe

[1751] Output: Recipe resubmitted to API-connected application

[1752] (Application example 2)

[1753] Next, a description will be given of Application Example 2 of Form 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".

[1754] Conventional school lunch systems have the problem that the creation of menus and adjustment of nutritional balance are done manually, which takes time and effort. In addition, it is difficult to provide optimal meals for individual users because the recipes cannot be adjusted taking into account the emotional state of the user. Furthermore, food delivery services also have the problem of not being able to suggest menus that correspond to the user's preferences and emotions.

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

[1756] In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying a default school lunch rule, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means for analyzing a user's emotions using an emotion engine and adjusting a recipe based on the results, and a means including an application installed on a smartphone, smart glasses, a head-mounted display, or a robot. This makes it possible to propose optimal menus and recipes that take into account the user's emotional state.

[1757] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[1758] "Specified period" refers to a specific period set for generating menus and recipes.

[1759] "School lunch rules" refers to regulations and guidelines regarding the provision of school lunches, such as "serve fish once a week."

[1760] "Budget" refers to the upper limit of expenses taken into consideration when creating menus and recipes.

[1761] "Nutritional balance" refers to the ratio of calories, proteins, fats, carbohydrates, and other nutrients contained in a meal.

[1762] "API-linked applications" refer to external software or services used to output the generated menus and recipes.

[1763] An "emotion engine" refers to technology that analyzes the user's emotional state and adjusts recipes based on the results.

[1764] A "smartphone" refers to a mobile phone that can connect to the Internet and install applications.

[1765] "Smart glasses" refers to a glasses-type device that has the function of displaying information.

[1766] "Head-mounted display" refers to a display device that is worn on the head.

[1767] "Robot" refers to an automated machine that performs programmed actions.

[1768] The system for implementing the present invention includes a generative AI, an emotion engine, a smartphone, smart glasses, a head-mounted display, and a robot. Specific embodiments of the system are described below.

[1769] System Configuration

[1770] 1. Generation AI

[1771] The AI ​​automatically generates menus and recipes for a specified period based on the specified school lunch rules, budget, and nutritional balance. The AI ​​also suggests optimal menus based on the information entered by the user.

[1772] 2. Emotion Engine

[1773] The emotion engine analyzes the user's emotional state and provides the results to the generative AI. The emotion engine recognizes emotions from the user's facial expressions and voice, collecting data in real time.

[1774] 3. Smartphones, smart glasses, head-mounted displays, robots

[1775] These devices are used to display the generated menu and recipes to the user, who can then review the menu and make adjustments if necessary.

[1776] Program Processing

[1777] The server receives information on school lunch rules, budget, and nutritional balance entered by the user and sends it to the generation AI. The generation AI generates menus and recipes based on this information and makes adjustments taking into account the emotion data from the emotion engine. The generated menus and recipes are output to smartphones, smart glasses, head-mounted displays, and robots through API-linked applications.

[1778] Hardware and software used

[1779] Generation AI: OpenAI API

[1780] Emotion Engine: Emotion Engine API

[1781] Devices: Smartphones, smart glasses, head-mounted displays, robots

[1782] Examples

[1783] The user opens the smartphone app and enters the following information:

[1784] Budget: 1,000 yen

[1785] Nutritional balance: Calories 600kcal, Protein 20g, Fat 10g, Carbohydrates 50g

[1786] Allergies: Nuts

[1787] School lunch rule: serve fish once a week

[1788] If the emotion engine recognizes the user's emotion as "joy," the generative AI will receive the following prompt:

[1789] Examples of prompt statements

[1790] User Emotion: Delight

[1791] Price: 1000 yen

[1792] Nutritional balance: Calories 600kcal, Protein 20g, Fat 10g, Carbohydrates 50g

[1793] Allergies: Nuts

[1794] School lunch rules: serve fish once a week

[1795] Use this information to generate the best menus and recipes.

[1796] Based on these prompts, the AI ​​will generate menus and recipes and suggest them to the user. The user can then review the suggested menus via their smartphone, smart glasses, head-mounted display, or robot and make adjustments as necessary.

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

[1798] Step 1:

[1799] Users open the smartphone app and enter school lunch rules, budget, nutritional balance, and allergy information.

[1800] Input: User-entered school lunch rules, budget, nutritional balance, and allergy information

[1801] Output: The entered information is sent to the server.

[1802] Step 2:

[1803] The server receives the entered information and sends it to the generation AI.

[1804] Input: School lunch rules, budget, nutritional balance, allergy information sent by the user

[1805] Output: The prompt sent to the generation AI

[1806] Step 3:

[1807] The generative AI generates menus and recipes for the specified period based on the prompt text.

[1808] Input: Prompt statement

[1809] Output: Generated menu and recipes

[1810] Step 4:

[1811] The emotion engine analyzes the user's emotional state and sends the results to the server.

[1812] Input: User's facial expressions and voice data

[1813] Output: Parsed emotion data

[1814] Step 5:

[1815] The server receives the emotion data and sends it to the generation AI.

[1816] Input: Emotion data

[1817] Output: Emotion data sent to the generative AI

[1818] Step 6:

[1819] Generative AI adjusts menus and recipes based on emotional data.

[1820] Input: emotion data, generated menu and recipe

[1821] Output: Adjusted menu and recipes

[1822] Step 7:

[1823] The server sends the adjusted menu and recipes to the API-integrated application.

[1824] Input: Adjusted menu and recipes

[1825] Output: Data sent to the API-integrated application

[1826] Step 8:

[1827] Smartphones, smart glasses, head-mounted displays, and robots receive data from API-connected applications and display it to the user.

[1828] Input: Data received from the API-integrated application

[1829] Output: The menu and recipes displayed to the user

[1830] Step 9:

[1831] The user reviews the displayed menu and recipes and makes adjustments as necessary.

[1832] Input: Menu and recipes confirmed by the user

[1833] Output: Final, adjusted menu and recipe

[1834] 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 voice indicating a user input for 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.

[1835] 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> ) and other generation AIs. The data generation model 58 is obtained by making a neural network perform deep learning. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating a voice, text data indicating a text, and image data indicating an image is input. The data generation model 58 performs inference on the input inference data according to 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.

[1836] Another example of generative AI is Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) are mentioned.

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

[1838] [Fourth embodiment]

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

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

[1841] 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 wide area network (WAN) and / or a local area network (LAN).

[1842] 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. In addition, the microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[1843] 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 the voice according to instructions from the processor 46.

[1844] Camera 42 is a small digital camera equipped with an optical system including a lens, an aperture, and a 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 (e.g., an imaging range defined by an angle of view equivalent to the width of the field of vision of an average healthy person).

[1845] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for transmitting and receiving various types of information between the processor 46 and the processor 28 via the network 54. The transmission and reception of various types of information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is performed in a secure state.

[1846] The control target 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, legs, etc. The posture and behavior of the robot 414 are controlled by controlling the motors of the arms, hands, legs, etc. 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.

[1847] Fig. 8 shows an example of 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.

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

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

[1850] In the robot 414, 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.

[1851] Next, the specific processing by the specific processing unit 290 of the data processing device 12 will be described.

[1852] "Example 1"

[1853] One embodiment of the present invention is a system that uses generation AI to automatically generate menus for a specified period. This system generates menus and recipes based on preset school lunch rules, budgets, nutritional balance, etc. The generated menus and recipes are output by an application linked to the API, and school lunch operators can use this to replace nutritionists with AI.

[1854] "Example 2"

[1855] As a specific example, consider the case where a school lunch provider uses this system. First, the school lunch provider specifies the school lunch rules (e.g., serving fish once a week), budget, and nutritional balance (e.g., calories per meal and the ratio of protein, fat, and carbohydrates) to the generation AI. Based on this information, the generation AI automatically generates menus and recipes for the specified period. The generated menus and recipes are output by an application linked to the API, and the school lunch provider can check them and make adjustments as necessary.

[1856] The process flow of each embodiment will be described below.

[1857] "Example 1"

[1858] Step 1: The school lunch provider specifies the default school lunch rules, budget, nutritional balance, etc. to the generation AI.

[1859] Step 2: The generation AI automatically generates menus and recipes for the specified period based on the specified information.

[1860] Step 3: The generated menu and recipes are output to the application that is linked to the API.

[1861] Step 4: The food service provider reviews the printed menu and recipes and makes adjustments as necessary.

[1862] "Example 2"

[1863] Step 1: The school lunch provider specifies the lunch rules (e.g., serving fish once a week), budget, and nutritional balance (e.g., calories per meal, and the ratio of protein, fat, and carbohydrates) to the generation AI.

[1864] Step 2: Based on this information, the generation AI automatically generates menus and recipes for the specified period.

[1865] Step 3: The generated menu and recipes are output to the application that is linked to the API.

[1866] Step 4: The food service provider reviews the printed menu and recipes and makes adjustments as necessary.

[1867] Example 1

[1868] Next, a description will be given of Example 1 of the embodiment 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".

[1869] Traditionally, school lunch menus were created manually by nutritionists, which took time and effort, and it was difficult to consider budgets and nutritional balance. In addition, specialized knowledge of nutritionists was required, and it is often difficult for school lunch operators to secure human resources. This has created a demand for efficient and effective menu creation.

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

[1871] In this invention, the server includes a means for the user to input conditions, a means for the server to receive the conditions, a means for the server to send a prompt to the generation AI model, a means for the generation AI model to generate a menu, a means for the server to send the generated menu to an API partner, and a means for the terminal to display the results. This allows the user to easily specify conditions and efficiently generate a menu.

[1872] The "means for the user to input conditions" is an interface that allows the user to input conditions such as school lunch rules, budget, and nutritional balance.

[1873] The "means for the server to receive the conditions" is a function that enables the server to receive and analyze the conditions sent from the user.

[1874] "Means for the server to send a prompt to the generative AI model" refers to a function for generating a prompt sentence based on the conditions received by the server and sending it to the generative AI model.

[1875] "Means for the generative AI model to generate a menu" refers to the function by which the generative AI model automatically creates a menu that meets the specified conditions based on the prompt text sent to it.

[1876] "Means for the server to send the generated menu to the API partner" refers to a function that enables the server to send the menu received from the generative AI model to the partner application via API.

[1877] "Means for the terminal to display the results" refers to a function for displaying the menu received from the API-connected application on the user's terminal.

[1878] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[1879] This invention is a system that uses a generative AI model to automatically generate a menu for a specified period. This system generates the menu and recipes based on the user's input of conditions such as school lunch rules, budget, and nutritional balance. The generated menu and recipes are output by an application linked to the API, and school lunch operators can use this to replace nutritionists with AI.

[1880] Hardware and Software Used

[1881] Hardware:

[1882] Terminal (the device through which the user enters the conditions, e.g. PC, tablet, smartphone)

[1883] Server (for processing data and running generative AI models)

[1884] software:

[1885] A web interface or dedicated application (an interface for users to enter conditions)

[1886] Server-side programs (e.g. Python's Flask framework)

[1887] Generative AI models (e.g. OpenAI's GPT-4)

[1888] API integration software (e.g. RESTful API)

[1889] Data processing and calculation

[1890] 1. The user enters the conditions

[1891] The user uses the terminal to input conditions such as school lunch rules, budget, nutritional balance, etc. For example, the user may input conditions such as "Create a menu for one week," "Budget per meal is within 500 yen," and "Calories are 600 kcal or less."

[1892] 2. The server receives the conditions

[1893] The conditions sent from the terminal are sent to the server as an HTTP request. The server receives the request and analyzes the conditions. For example, the server receives the request using the Python Flask framework.

[1894] 3. The server sends a prompt to the generative AI model

[1895] The server generates a prompt based on the received conditions and sends it to the generative AI model. For example, the prompt might be, "Please create a menu for one week. Please keep the budget per meal within 500 yen and calories below 600 kcal." The server sends this prompt to the generative AI model.

[1896] 4. A generative AI model generates menus

[1897] The generative AI model generates a menu based on the prompt sent in. For example, the generative AI model generates a menu such as "Monday: teriyaki chicken, spinach ohitashi, rice" or "Tuesday: grilled salmon, miso soup, salad."

[1898] 5. The server sends the generated menu to the API partner

[1899] The server sends the menu received from the generative AI model to the partner application via API. For example, the server sends data using a RESTful API. The partner application is a dedicated management system used by a food service provider.

[1900] 6. The device will display the results.

[1901] The terminal displays the menu received from the API-linked application. The user can check it and modify or regenerate it as necessary. For example, the user can send a request again such as "I want to change Monday's menu."

[1902] Examples

[1903] If a user enters the conditions "Create a menu for one week," "Budget per meal is less than 500 yen," and "Calories are less than 600 kcal," the system will generate a menu like the one below.

[1904] Monday: Teriyaki chicken, spinach salad, rice

[1905] Tuesday: Grilled salmon, miso soup, salad

[1906] Wednesday: Pork with ginger, shredded cabbage, rice

[1907] Thursday: Curry rice, salad

[1908] Friday: Hamburger steak, potato salad, rice

[1909] Example prompt:

[1910] "Please create a menu for one week. Please limit each meal to 500 yen or less and keep the calories to 600 kcal or less."

[1911] In this way, users can easily specify conditions and efficiently generate menus through the system.

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

[1913] Step 1:

[1914] The user enters the conditions

[1915] Specific operation: The user uses a dedicated application on the device or a web interface to input conditions such as school lunch rules, budget, and nutritional balance.

[1916] Input: School lunch rules, budget, nutritional balance, and other conditions

[1917] Output: The entered condition data

[1918] Data processing: Convert the conditions entered by the user into a data format such as JSON.

[1919] Step 2:

[1920] The server receives the conditions

[1921] Specific operation: The conditions sent from the terminal are sent to the server as an HTTP request. The server receives this request and analyzes the conditions.

[1922] Input: Condition data entered by the user

[1923] Output: Parsed condition data

[1924] Data processing: The server analyzes the received condition data and converts it into a format that can be used internally.

[1925] Step 3:

[1926] The server sends prompts to the generative AI model

[1927] Specific operation: The server generates a prompt sentence based on the received conditions and sends it to the generative AI model.

[1928] Input: Parsed condition data

[1929] Output: The prompt sent to the generative AI model

[1930] Data processing: The server generates prompt sentences based on the condition data and converts them into a format suitable for the generative AI model.

[1931] Step 4:

[1932] A generative AI model generates menus

[1933] How it works: The generative AI model generates a menu based on the prompt text sent.

[1934] Input: prompt statement

[1935] Output: Generated menu data

[1936] Data processing: The generative AI model analyzes the prompt text and generates a menu that meets the conditions.

[1937] Step 5:

[1938] The server sends the generated menu to the API partner.

[1939] Specific operation: The server sends the menu received from the generative AI model to the linked application via API.

[1940] Input: Generated menu data

[1941] Output: Menu data sent to API partner

[1942] Data processing: The server converts the generated menu data into a format that can be received by the API-integrated application.

[1943] Step 6:

[1944] The terminal displays the results

[1945] Specific operation: The device displays the menu received from the API-linked application. The user can review it and modify or regenerate it as necessary.

[1946] Input: Menu data received from API partner

[1947] Output: Menu data displayed on the terminal

[1948] Data processing: The terminal converts the received menu data into a format that is easy for the user to view and displays it.

[1949] (Application example 1)

[1950] Next, a description will be given of Application Example 1 of Form 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".

[1951] In conventional school lunch systems, nutritionists had to manually create menus and manage food ordering and delivery, which was time-consuming and labor-intensive. In addition, creating menus that take nutritional balance and budget into account required specialized knowledge, making it difficult to do efficiently. Furthermore, ordering food and tracking delivery status were also done manually, which made it prone to errors and delays.

[1952] 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. In this invention, the server includes a means for automatically generating a menu for a specified period using a generation AI, a means for specifying predetermined school lunch rules, a budget, nutritional balance, etc., a means for generating a menu and recipes, a means for outputting in an application linked with the API, a means for acquiring user input, a means for automatically ordering ingredients based on the generated menu, and a means for tracking and notifying the delivery status in real time. This enables efficient menu creation that takes nutritional balance and budget into consideration, and allows for integrated management from ordering ingredients to delivery.

[1953] "Generative AI" is artificial intelligence that automatically generates data based on specified conditions.

[1954] "Specified Period" refers to a specific period set by the User.

[1955] A "menu" is a list of the meals served during a particular period of time.

[1956] "School lunch rules" refers to regulations and guidelines regarding the provision of school lunches.

[1957] A "budget" refers to the maximum cost for ingredients or services for a particular period of time.

[1958] "Nutritional balance" refers to the appropriate distribution of nutrients necessary to maintain health.

[1959] A "recipe" is a list of steps and ingredients for making a particular dish.

[1960] An "API-integrated application" is an application that has an interface for exchanging data with other software or services.

[1961] "User Input" refers to information or data provided by a user to a system.

[1962] "Means for automatically ordering ingredients" refers to a function for automatically ordering necessary ingredients based on the generated menu.

[1963] "Means of tracking and notifying delivery status in real time" refers to a function that monitors the delivery status of ordered ingredients in real time and notifies the user.

[1964] The system for implementing this invention utilizes a generative AI model to automatically generate a menu for a specified period. A specific embodiment of this system will be described below.

[1965] System Configuration

[1966] 1. Getting user input:

[1967] Users use a device such as a smartphone or tablet to enter information such as the specified period, budget, and nutritional balance.

[1968] Hardware used: Smartphone, tablet

[1969] Software used: Mobile application (iOS / Android)

[1970] 2. Invoke the generative AI model:

[1971] The server sends prompts to the generative AI model based on the user's input data and generates a menu for the specified period.

[1972] Software used: Generative AI models (e.g. OpenAI GPT-4)

[1973] Example prompt: "Please generate a menu for a 7-day period with a budget of 5,000 yen and a nutritional balance of high protein and low fat."

[1974] 3. Menu and recipe generation:

[1975] The server retrieves the menu and recipes returned by the generative AI model and displays them on the user's device.

[1976] Software used: Mobile application

[1977] 4. Automated food ordering:

[1978] The server then lists the ingredients needed based on the proposed menu and sends the order to a partner food delivery service.

[1979] Software used: API integration (e.g. food delivery service API)

[1980] 5. Tracking your delivery:

[1981] After the order is confirmed, the server tracks the delivery status in real time and notifies the user's terminal.

[1982] Software used: Mobile applications, notification systems (e.g. Firebase Cloud Messaging)

[1983] Examples

[1984] A user logs into the application using their smartphone and enters the following information:

[1985] Specified period: 7 days

[1986] Price: 5,000 yen

[1987] Nutritional balance: high protein, low fat

[1988] With this information, the server sends the following prompt to the generative AI model:

[1989] "Please create a menu for a specified period of 7 days, a budget of 5,000 yen, and a nutritionally balanced high protein, low fat menu."

[1990] The menu and recipes returned by the generative AI model are displayed on the user's smartphone. The user can review the suggested menu and the necessary ingredients are automatically ordered. Once the order is confirmed, the delivery status is tracked in real time and the user is notified.

[1991] In this way, users can easily create nutritionally balanced meal plans and manage everything from ordering ingredients to delivery all in one place.

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

[1993] Step 1:

[1994] A user uses a device such as a smartphone or tablet to input information such as a specified period, budget, and nutritional balance. The input information is sent from the device to a server. The input data includes a specified period (e.g., 7 days), budget (e.g., 5,000 yen), and nutritional balance (e.g., high protein, low fat).

[1995] Step 2:

[1996] The server receives the input data sent by the user, creates a prompt sentence, and sends it to the generative AI model. An example of a prompt sentence is, "Please generate a menu for the specified period of 7 days, the budget of 5,000 yen, and a nutritional balance of high protein and low fat." The server sends this prompt sentence to the generative AI model, instructing it to generate a menu for the specified period.

[1997] Step 3:

[1998] The generative AI model generates menus and recipes for the specified period based on the prompt text received from the server. The generative AI model analyzes the input data and generates the optimal menu taking into account the predefined school lunch rules, budget, and nutritional balance. The generated menus and recipes are returned to the server.

[1999] Step 4:

[2000] The server receives the menu and recipes returned from the generative AI model and transmits them to the user's terminal. The user's terminal displays the received menu and recipes. The user can confirm the suggested menu.

[2001] Step 5:

[2002] The server lists the ingredients required based on the proposed menu and sends an order to the partner food delivery service. The server sends the order data to the food delivery service using API integration. The order data includes the list and quantities of the ingredients required.

[2003] Step 6:

[2004] After the order is confirmed, the server tracks the delivery status in real time and notifies the user's terminal. The server receives delivery status data from the food delivery service and transmits it to the user's terminal. The user's terminal displays the delivery status in real time and notifies the user.

[2005] In this way, users can easily create nutritionally balanced meal plans and manage the entire process from ordering ingredients to delivery.

[2006] Example 2

[2007] Next, a second embodiment of the second embodiment will be described. 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".

[2008] The traditional process of creating school lunch menus is time-consuming and labor-intensive, as it is done manually by nutritionists. In addition, creating menus while taking into account nutritional balance and budgets is complicated, making it difficult to operate efficiently. Furthermore, the specialized knowledge of nutritionists is required, making it difficult to secure human resources. There is a demand for a system that can solve these problems and create school lunch menus efficiently and automatically.

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

[2010] In this invention, the server includes a means for a user to access the system, a means for a user to input school lunch rules, a budget, and nutritional balance, a means for the server to receive the input data and generate a prompt sentence for the generative AI model, a means for the server to send the prompt sentence to the generative AI model, a means for the generative AI model to generate a menu and recipes, a means for the server to send the generated menu and recipes to an application via an API, a means for the terminal to display the menu and recipes through the application, and a means for the user to check the menu and recipes and adjust them as necessary. This makes it possible to automate and streamline the creation of school lunch menus.

[2011] A "user" is a person or organization that accesses the system and inputs information such as school lunch rules, budget, and nutritional balance.

[2012] A "server" is a computer system that receives input data from a user, generates prompt sentences, and sends them to the generative AI model.

[2013] A "generative AI model" is an artificial intelligence model that automatically generates menus and recipes based on user input data.

[2014] A "prompt sentence" is text-based input data that provides instructions to a generative AI model.

[2015] An "API" is an interface for exchanging data between different software applications.

[2016] An "application" is a software program that a user accesses through a terminal and that displays the generated menus and recipes.

[2017] A "terminal" is a device (such as a PC, tablet, or smartphone) that a user uses to access the system.

[2018] A "menu" is a plan of meals to be served for a particular period of time.

[2019] A "recipe" is a list of specific steps and ingredients for cooking a meal based on a menu.

[2020] "School lunch rules" are specific conditions or standards regarding the provision of school lunches (e.g., serving fish once a week).

[2021] A "budget" is the maximum amount that can be spent on each school lunch meal.

[2022] "Nutritional balance" is a standard regarding the nutritional value of a meal, such as the calories per meal and the ratio of protein, fat, and carbohydrates.

[2023] This invention is a system for efficiently creating menus and recipes for school meal service providers. The system automatically generates menus and recipes using a generative AI model after the user inputs school meal rules, budget, and nutritional balance. A specific embodiment of this system is described below.

[2024] A user accesses the system's web application using a terminal (PC, tablet, smartphone, etc.). The user enters authentication information on the login screen and logs into the system. After logging in, the user moves to the dashboard screen and clicks the "Create a new menu" button. In the input form that is displayed, the user enters school lunch rules (e.g., provide fish once a week), budget (e.g., no more than 500 yen per meal), and nutritional balance (e.g., 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal), and clicks the "Submit" button.

[2025] The server receives the data entered by the user and generates a prompt to be sent to the generative AI model based on the data. The prompt is a text that specifically describes the user's requirements. For example, the following prompt is generated:

[2026] Example prompt:

[2027] Create a school lunch menu for the week. The following conditions must be met:

[2028] Serve fish once a week

[2029] Budget is under 500 yen per meal

[2030] The nutritional balance is 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal.

[2031] The server sends the generated prompt to the generative AI model, which is an advanced natural language processing model such as OpenAI's GPT-3. The generative AI model automatically generates menus and recipes for the specified period based on the received prompt. The generated menus and recipes are returned to the server in text format.

[2032] The server receives the menu and recipes returned from the generative AI model and sends them to the linked application via API. The API uses, for example, a RESTful API. The application on the terminal displays the menu and recipes received from the server on the user interface. The user can visually check this.

[2033] The user can review the displayed menu and recipe and make adjustments as necessary, such as changing certain ingredients or adjusting portion sizes. Once adjustments are complete, the user can save the final menu and recipe.

[2034] This system allows school meal operators to create menus and recipes efficiently and automatically, significantly reducing time and labor. It also makes it easier to create menus that take into account nutritional balance and budgets, allowing them to provide high-quality school meals even without specialized knowledge.

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

[2036] Step 1:

[2037] A user accesses the system.

[2038] Input: A user uses a terminal to access the system's web application and enters login information.

[2039] Output: The user logs into the system and navigates to the dashboard screen.

[2040] Specific operations: A user opens a browser, enters the system URL, and accesses the system. On the login screen, the user enters the "user name" and "password," and clicks the "Login" button.

[2041] Step 2:

[2042] The user inputs school lunch rules, budget, and nutritional balance.

[2043] Input: The user clicks the "Create a new menu" button on the dashboard screen and enters school lunch rules, budget, and nutritional balance in the input form that appears.

[2044] Output: The data entered by the user is sent to the server.

[2045] Specific actions: The user clicks the "Create a new menu" button, enters the following into the input form that appears: "Provide fish once a week," "Budget is 500 yen or less per meal," "Calories 600 kcal, protein 20 g, fat 15 g, carbohydrates 80 g," and clicks the "Submit" button.

[2046] Step 3:

[2047] The server receives the input data and generates a prompt for the generative AI model.

[2048] Input: User-entered school lunch rules, budget, and nutritional balance data.

[2049] Output: The prompt to send to the generative AI model.

[2050] Specific operation: The server receives the user's input data and generates a prompt sentence saying, "Please create a school lunch menu for one week. The following conditions must be met: fish must be provided once a week, the budget must be within 500 yen per meal, and the nutritional balance must be 600 kcal, 20 g protein, 15 g fat, and 80 g carbohydrates per meal."

[2051] Step 4:

[2052] The server sends a prompt to the generative AI model.

[2053] Input: The generated prompt statement.

[2054] Output: The prompt is sent to the generative AI model.

[2055] Specific operation: The server sends the generated prompt text to the generative AI model.

[2056] Step 5:

[2057] A generative AI model generates menus and recipes.

[2058] Input: The prompt text sent by the server.

[2059] Output: Generated menu and recipes.

[2060] Specific operation: Based on the prompt, the generative AI model generates a menu and recipe, such as "Monday: grilled fish set meal, Tuesday: chicken curry, ...", and returns it to the server.

[2061] Step 6:

[2062] The server sends the generated menu and recipes to the application via an API.

[2063] Input: Meal plans and recipes returned by a generative AI model.

[2064] Output: The menu and recipes sent to the application.

[2065] Specific operation: The server receives the generated menu and recipes and sends them to the linked application via API.

[2066] Step 7:

[2067] The device displays menus and recipes through the application.

[2068] Input: Menu and recipes sent from the server.

[2069] Output: The menu and recipe displayed in a user interface.

[2070] Specific operation: The application on the device displays a menu and recipes such as "Monday: Grilled fish set meal, Tuesday: Chicken curry, ..."

[2071] Step 8:

[2072] User reviews menu and recipes and adjusts as needed.

[2073] Input: Displayed menu and recipe.

[2074] Output: Final, adjusted menu and recipes.

[2075] Specific actions: The user checks the displayed menu and recipes, makes adjustments such as "changing Tuesday's chicken curry to beef curry," and clicks the "Save" button.

[2076] (Application example 2)

[2077] Next, a description will be given of Application Example 2 of Form 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".

[2078] In conventional school lunch businesses and meal provision services, planning menus and managing nutritional balance was time-consuming and required specialized nutritionists. In addition, in order to meet the diverse needs of users, it was necessary to take into account individual dietary rules, budgets, and nutritional balance, which also placed a heavy burden on the users. There is a demand for a system that can solve these problems and generate and manage menus efficiently and flexibly.

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

[2080] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying predetermined dietary rules, budget, nutritional balance, etc., a means for generating the menu and recipes, a means for outputting in an application linked with the API, a means for generating the menu and recipes based on the dietary rules, budget, and nutritional balance specified by the user, and a means for confirming and adjusting the generated menu and recipes in a smartphone application. This enables the user to easily plan a nutritionally balanced menu and use a food delivery service.

[2081] "Generative AI" is artificial intelligence that automatically generates data based on specified rules and conditions.

[2082] A "menu" is a list of the meals served during a particular period of time.

[2083] A "recipe" is a detailed description of the steps and ingredients for making a particular dish.

[2084] A "dietary rule" refers to a specific condition or restriction regarding food, such as the use of a specific food ingredient once a week.

[2085] "Budget" refers to the financial constraints available for a specific period or conditions.

[2086] "Nutritional balance" refers to the appropriate proportions and amounts of nutrients contained in a meal.

[2087] An "API-integrated application" is an application that has an interface for exchanging data with other systems or services.

[2088] A "smartphone application" is a software program that runs on a smartphone.

[2089] "User" refers to any individual or organization that uses this system.

[2090] A "food delivery service" is a service that delivers meals ordered by a user to a specified location.

[2091] A system for implementing this invention includes means for automatically generating a menu for a specified period using generation AI, means for specifying pre-defined dietary rules, budget, nutritional balance, etc., means for generating menus and recipes, means for outputting in an application that is linked to the API, means for generating menus and recipes based on dietary rules, budget, and nutritional balance specified by the user, and means for checking and adjusting the generated menus and recipes within a smartphone application.

[2092] The server uses the generative AI model to generate menus and recipes based on the user's specified dietary rules, budget, and nutritional balance. Specifically, the generative AI model creates prompts based on information entered by the user through the smartphone application, and generates menus and recipes using the OpenAI API. The generated menus and recipes can be viewed within the smartphone application, and the user can make adjustments as necessary.

[2093] The hardware used is a smartphone, and the software is Python and OpenAI API. Data processing involves converting the dietary rules, budget, and nutritional balance entered by the user into prompt text and sending it to the generative AI model. Data calculation involves the generative AI model generating menus and recipes based on the prompt text.

[2094] As a specific example, if a user enters the conditions "include vegetarian menu once a week," "less than 500 yen per meal," and "600 calories, 20g protein, 10g fat, 80g carbohydrates per meal," the generation AI will generate a week's worth of menus and recipes that meet these conditions.

[2095] An example of a prompt is:

[2096] Menu rule: Include vegetarian menu once a week

[2097] Budget: Less than 500 yen per meal

[2098] Nutritionally balanced: 600 calories, 20g protein, 10g fat, 80g carbohydrates per serving

[2099] Use this information to generate a week's worth of menus and recipes.

[2100] In this way, users can easily plan nutritionally balanced meals and use food delivery services.

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

[2102] Step 1:

[2103] The user launches the smartphone application and inputs information such as dietary rules, budget, and nutritional balance.

[2104] Input: User-specified dietary rules, budget, nutritional balance

[2105] Output: Condition data entered

[2106] Specific operation: The user enters conditions into the application's input form and presses the submit button.

[2107] Step 2:

[2108] The terminal transmits the input condition data to the server.

[2109] Input: Criteria data entered by the user

[2110] Output: Condition data sent to the server

[2111] Specific operation: The smartphone application makes an API request to send condition data to the server.

[2112] Step 3:

[2113] The server generates a prompt sentence based on the received condition data.

[2114] Input: Condition data sent to the server

[2115] Output: Generated prompt statement

[2116] Specific operation: The server parses the condition data and embeds the data into a template for generating a prompt sentence.

[2117] Step 4:

[2118] The server sends the generated prompt text to the OpenAI API to generate a menu and recipe.

[2119] Input: Generated prompt text

[2120] Output: Generated menu and recipe data

[2121] Specific operation: The server sends a prompt to the OpenAI API, and the generative AI model generates a menu and recipe.

[2122] Step 5:

[2123] The server transmits the generated menu and recipe data to the smartphone application.

[2124] Input: Generated menu and recipe data

[2125] Output: Menu and recipe data sent to the smartphone application

[2126] Specific operation: The server performs an API response to return the generated data to the smartphone application.

[2127] Step 6:

[2128] The terminal displays the received menu and recipe data, and the user can check and adjust it.

[2129] Input: Menu and recipe data sent to the smartphone application

[2130] Output: Menu and recipe data confirmed and adjusted by the user

[2131] Specific operation: The smartphone application displays the received data on the screen and provides an interface for the user to make adjustments as necessary.

[2132] In addition, 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.

[2133] "Example 1"

[2134] As one embodiment of the present invention, a system incorporating an emotion engine is provided. In this system, the generation AI includes an emotion engine that recognizes the user's emotion. Specifically, the generation AI recognizes the user's emotional state from information such as text, voice, and images input by the user to the system. This emotion engine can recognize the user's basic emotions, such as joy, sadness, anger, and surprise. Based on the recognition results, the generation AI automatically generates a menu. For example, if the user expresses joy, the generation AI incorporates ingredients and dishes that the user would like into the menu. Also, if the user expresses sadness, the generation AI incorporates ingredients and dishes that would cheer up the user into the menu. In this way, it is possible to generate a menu that takes into account the user's emotional state.

[2135] "Example 2"

[2136] Furthermore, as another embodiment of the present invention, a system is provided in which an emotion engine adjusts a recipe based on the emotion of a user. Specifically, the generation AI adjusts the recipe based on the recognition result of the emotion engine. For example, if a user shows an emotion of joy, the generation AI incorporates a recipe that the user would like into the recipe. Also, if a user shows an emotion of sadness, the generation AI incorporates a recipe that would cheer up the user. In this way, it is possible to adjust the recipe taking into account the emotional state of the user.

[2137] The process flow of each embodiment will be described below.

[2138] "Example 1"

[2139] Step 1: The user inputs information into the system. This information can be in various forms, such as text, audio, or images.

[2140] Step 2: The emotion engine recognizes the user's emotional state from the input information. This emotion engine has the ability to recognize basic emotions such as happiness, sadness, anger, and surprise.

[2141] Step 3: The generation AI automatically generates a menu based on the recognition results of the emotion engine. Depending on the user's emotional state, the generation AI selects ingredients and dishes to be included in the menu.

[2142] "Example 2"

[2143] Step 1: The user inputs information into the system. This information can be in various forms, such as text, audio, or images.

[2144] Step 2: The emotion engine recognizes the user's emotional state from the input information. This emotion engine has the ability to recognize basic emotions such as happiness, sadness, anger, and surprise.

[2145] Step 3: The generative AI adjusts the recipe based on the recognition results of the emotion engine. Depending on the user's emotional state, the generative AI selects the cooking methods to incorporate into the recipe.

[2146] Example 1

[2147] Next, a description will be given of Example 1 of the embodiment 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".

[2148] Conventional school lunch menu generation systems have the problem that it takes time and effort for nutritionists to create menus manually. In addition, it is not possible to generate menus that take into account the emotional state of the user, making it difficult to provide menus that meet the needs of individual users. Furthermore, there was a demand for a system that would allow school lunch operators to replace nutritionists with AI.

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

[2150] In this invention, the server includes a means for automatically generating a menu for a specified period using generation AI, a means for specifying default school lunch rules, budget, nutritional balance, etc., a means for recognizing emotions from user input information, a means for generating a menu and recipes based on the recognized emotions, and a means for outputting in an application linked to the API. This makes it possible to generate a menu that takes into account the emotional state of the user, and provides a system that allows school lunch operators to replace nutritionists with AI.

[2151] "Generative AI" is artificial intelligence that automatically generates menus and recipes based on specified conditions.

[2152] The "specified period" refers to a specific period set by the user, and serves as the basis for generating a menu within that period.

[2153] "School lunch rules" refer to the regulations and guidelines regarding the provision of school lunches, based on which the menu is generated.

[2154] A "budget" refers to the upper limit of costs that are taken into consideration when generating a menu, and serves as a standard for creating a menu within a specified amount.

[2155] "Nutritional balance" refers to the distribution of nutrients necessary to provide a healthy meal, and menus are created based on this.

[2156] "Means for recognizing emotions" refers to technology that analyzes and recognizes a user's emotional state from input information (text, voice, images, etc.).

[2157] An "API-integrated application" refers to software that interacts with the server to receive and display the generated menus and recipes.

[2158] A "nutritionist" is a professional who creates menus taking into account the nutritional balance of meals, and in this invention, the generative AI takes on that role.

[2159] This invention is a system that uses generation AI to automatically generate menus for a specified period. The system generates menus and recipes based on conditions such as school lunch rules, budgets, and nutritional balance. The generated menus and recipes are output to an application linked with the API and can be used by school lunch providers.

[2160] Hardware and Software Used

[2161] Hardware: Servers, terminals (PCs, smartphones)

[2162] Software: Generative AI models (e.g. GPT-4), emotion engines (e.g. IBM Watson Tone Analyzer), API-integrated applications

[2163] Explanation of program processing

[2164] User Input

[2165] The user uses a terminal to input conditions such as school lunch rules, budget, nutritional balance, etc. into the system. For example, the user might input, "Generate a menu for one week. The budget is 500 yen per day, and the nutritional balance is more vitamin C."

[2166] Emotion recognition by emotion engine

[2167] The server receives information such as text, voice, and images entered by the user and uses an emotion engine to recognize the user's emotional state. For example, if a user enters "I've been tired lately," the emotion engine recognizes the "feeling of fatigue."

[2168] Menu generation by generative AI

[2169] The server uses the generative AI model to generate menus and recipes based on the emotion engine's recognition results and the conditions specified by the user. For example, if the user expresses fatigue, the generative AI generates a menu using ingredients rich in vitamin C. Specifically, the generative AI model is input with the following prompt sentence:

[2170] "The user is tired, so please generate a week's worth of meals using ingredients rich in Vitamin C. The budget is 500 yen per day."

[2171] Output via API integration

[2172] The server outputs the generated menu and recipes to the linked application via the API. For example, the menu is displayed in an application used by a food service provider. Specifically, the server sends the generated data to the API endpoint via a POST request.

[2173] Examples

[2174] User input:

[2175] The user enters on the terminal, "Please generate a menu for one week. The budget is 500 yen per day, and the nutritional balance is more vitamin C" and clicks the send button.

[2176] Emotion Recognition with Emotion Engine:

[2177] The server receives the user's input and sends the text data to the emotion engine.

[2178] The emotion engine recognizes "fatigue" and returns the result to the server.

[2179] Menu generation by generative AI:

[2180] The server sends a prompt to the generative AI model based on the results of the emotion engine and the user's conditions.

[2181] The generative AI model generates the menu and returns the results to the server.

[2182] Output via API integration:

[2183] The server sends the generated menu data to the API endpoint via a POST request.

[2184] The application displays the received data so that the food service provider can review it.

[2185] In this way, the system performs a series of processes from user input, emotion recognition, menu generation, and output.

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

[2187] Step 1:

[2188] The user inputs the conditions.

[2189] The user uses a terminal to input conditions such as school lunch rules, budget, and nutritional balance into the system. For example, the user might input, "Generate a one-week menu. The budget is 500 yen per day, and the nutritional balance is more vitamin C," and then click the send button. The input data is sent to the server.

[2190] Step 2:

[2191] The server recognizes the user's emotions using an emotion engine.

[2192] The server receives text data entered by the user and sends it to the emotion engine. The emotion engine analyzes the text data and recognizes the user's emotional state. For example, in response to the input "I've been tired lately," the emotion engine recognizes "feeling tired" and returns the result to the server. The input is the user's text data, and the output is the recognized emotion data.

[2193] Step 3:

[2194] The server generates the menu using a generative AI model.

[2195] The server sends a prompt to the generative AI model based on the emotion engine's recognition results and the conditions specified by the user. For example, a prompt such as "The user is tired, so please generate a week's menu using ingredients rich in vitamin C. The budget is 500 yen per day" is sent to the generative AI model. The generative AI model...

Claims

1. A means for recognizing an emotion of a user from input information of the user using an emotion engine; A means for generating a menu and a recipe using a generative AI model based on a prompt sentence that combines the recognized emotion and at least one of the school lunch rules, the budget, and the nutritional balance in the input information; A system including:

2. The system according to claim 1 , further comprising a means for outputting the generated menu and recipe to a linked application via an API.

3. The system of claim 1 , further comprising means for ordering the generated menu from a food delivery service.

Images