System

Abstract

A system is provided.SOLUTION: This system includes a means for inputting user information, a means for acquiring store information, a means for generating a recipe on the basis of the user information and the store information, a means for presenting the generated recipe to a user, and a means for guiding necessary food materials from the recipe.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] In today's grocery market, consumers spend a lot of effort planning their daily meals and choosing healthy foods, while retailers often discard unsold products or products approaching their expiration dates. Furthermore, it is difficult to match the needs of consumers and retailers, resulting in food waste. This invention aims to solve these issues by using generative AI, pursuing the benefits of both consumers and retailers and reducing food waste. [Means for solving the problem]

[0005] The present invention solves the above-mentioned problems with a system including a means for inputting user information, a means for acquiring store information, a means for generating a recipe based on the user information and the store information, a means for presenting the generated recipe to the user, and a means for providing guidance on ingredients needed from the recipe.Furthermore, by including a means for identifying products that are close to their expiration date and generating a recipe that prioritizes the use of the identified products, and a means for suggesting plus-one products such as beverages and confectioneries, it is possible to more specifically reduce food waste and promote sales.

[0006] "User information" refers to attribute information about individual consumers, such as their family structure, food preferences, budget, cooking experience, and health condition.

[0007] "Store information" refers to business information about a store, such as inventory information, prices, expiration dates, and featured products held by the retail store.

[0008] "Recipe generation means" refers to a method or device for generating an optimal cooking recipe based on user information and store information.

[0009] "Recipe presentation means" refers to a method or device for displaying or informing consumers of a created recipe.

[0010] "Ingredient guidance means" refers to a method or device for instructing a consumer on the ingredients needed and where to buy them based on a selected recipe.

[0011] The "expiration date identification means" refers to a method or device for identifying products with an approaching expiration date from store information and generating a recipe based on that information.

[0012] The "plus one product suggestion means" refers to a method or device for suggesting additional products such as beverages and confectioneries based on the user's preferences and selected recipes. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0021] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0034] The present invention is a system that reduces food waste and promotes sales by generating optimal recipes based on user information and store information and presenting them to consumers. Specifically, this system is configured and operates as follows.

[0035] System Configuration

[0036] This system, "Smart Basket," consists of a user device, a server, and a database. The user device is a smartphone or tablet, which communicates with the server to send and receive information. The server runs a program incorporating generative AI to generate recipes and analyze data. User information and store information is stored in the database, which the server accesses to retrieve the necessary information.

[0037] Program processing

[0038] Obtaining user information

[0039] Users log in to the "Smart Basket" app and enter information such as family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to the server, which stores it in a database and creates a user profile.

[0040] Obtaining store information

[0041] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database.

[0042] Generating recipe candidates

[0043] The server generates a recipe by calling the recipe GPT based on the user and store information. The recipe GPT takes into account the user profile (e.g., likes Japanese food, has an egg allergy) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate the optimal recipe. The generated recipe candidates are stored in a database.

[0044] Recipe presentation and product information

[0045] The device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[0046] Proposal for unsold products

[0047] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize the use of the identified products. Recipes based on this information are also suggested to the user on the device.

[0048] Plus One Proposal

[0049] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the "plus one" item suggestion to the user, who can then choose whether to add it to their shopping list.

[0050] Advertisement product proposals

[0051] When a food manufacturer provides advertising campaign information to the server, the server calls the recipe GPT to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[0052] Specific examples

[0053] Example 1: Customer A's case

[0054] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[0055] 2. The device sends the input information to the server, which updates the user profile.

[0056] 3. The server retrieves the store information and stores it in the database.

[0057] 4. The server calls the recipe GPT to generate and save a "Japanese food recipe."

[0058] 5. The device provides the recipe to user A and displays a shopping list and store information.

[0059] 6. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[0060] 7. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[0061] Example 2: Advertising

[0062] 1. Food manufacturers provide information about new products to a server.

[0063] 2. The server calls the recipe GPT to generate a recipe containing the advertised product.

[0064] 3. The server saves the generated recipe in the database.

[0065] 4. The device notifies User B of the recipe that includes the advertised product. User B adds the suggested product to their shopping list.

[0066] The processing flow will be explained below.

[0067] Step 1:

[0068] The user logs in to the "Smart Basket" app.

[0069] Step 2:

[0070] The device prompts the user to enter information such as family composition, food preferences, budget, cooking experience, and health status.

[0071] Step 3:

[0072] The terminal transmits the input user information to the server.

[0073] Step 4:

[0074] The server stores the received user information in a database and updates the user profile.

[0075] Step 5:

[0076] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc.

[0077] Step 6:

[0078] The server analyzes the store information it has acquired and processes it as necessary (e.g., standardizing date formats, cleaning data).

[0079] Step 7:

[0080] The server stores the analyzed store information in a database.

[0081] Step 8:

[0082] The server calls the recipe manager GPT based on the user information and store information to generate a recipe.

[0083] Step 9:

[0084] The recipe manager, GPT, takes into account the customer profile (e.g., likes Japanese food, allergy to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate optimal recipe candidates.

[0085] Step 10:

[0086] The server stores the generated recipes in a database for each user.

[0087] Step 11:

[0088] The terminal displays a notification of the recipe suggestion to the user.

[0089] Step 12:

[0090] The user opens the app and sees the suggested recipes.

[0091] Step 13:

[0092] The device displays the recipe details (ingredients, instructions) and the location of the ingredients (location within the store) to the user.

[0093] Step 14:

[0094] Users select their favorite recipes and add them to their shopping list.

[0095] Step 15:

[0096] The server identifies products that are nearing expiration dates or are overstocked.

[0097] Step 16:

[0098] The server calls the recipe manager GPT again to generate a recipe that prioritizes the use of the identified products.

[0099] Step 17:

[0100] Recipe GPT generates recipes using these products.

[0101] Step 18:

[0102] The server updates the recipe database to suggest the generated recipes to the user.

[0103] Step 19:

[0104] The device notifies the user of suggestions for additional products (e.g., drinks or sweets).

[0105] Step 20:

[0106] The server obtains the information about the advertised products and calls the recipe GPT to generate a recipe that includes the advertised products.

[0107] Step 21:

[0108] Recipe GPT generates recipes that include the advertised products.

[0109] Step 22:

[0110] The server stores the advertised recipes in a database and suggests them to users who meet certain conditions.

[0111] Step 23:

[0112] The terminal notifies the user of the advertised recipe and encourages them to make a purchase.

[0113] Example 1

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

[0115] In today's food market, food waste due to expired or unsold products is a major problem. In addition, inventory management in stores is becoming increasingly complex, and there is a lack of information available to help consumers purchase ingredients efficiently. Furthermore, the need for recipe suggestions tailored to consumers' preferences and health conditions is not being met. There is a need for a system that can solve these issues.

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

[0117] In this invention, the server includes means for inputting user information, means for acquiring store information at regular intervals, means for generating recipes using a generative AI model based on the user information and the store information, means for presenting the generated recipes to a user terminal, means for displaying to the user details of ingredients needed from the recipes and a sales area guide, means for identifying products that are close to their expiration date or are in excess of stock, regenerating recipes that prioritize the identified products, and presenting the recipes to the user terminal, and means for identifying plus-one products based on the user's purchase history and preference information, and suggesting the identified products to the user. This makes it possible to reduce food waste and improve the consumer shopping experience.

[0118] "User information" refers to personal information provided by a user to the system, including family composition, food preferences, budget, cooking experience, health status, and the like.

[0119] "Store information" refers to data such as inventory information, prices, expiration dates, featured products, etc., related to a particular store.

[0120] "Generative AI model" refers to an artificial intelligence model used to automatically generate optimal recipes based on user and store information.

[0121] "Recipe" refers to information provided to a user that includes instructions and a list of ingredients needed to prepare a particular dish.

[0122] "User terminal" refers to a device used by a user to access the system and input or receive information, including smartphones, tablets, etc.

[0123] "Products with an approaching expiration date" refers to products whose best-before date or expiration date is approaching.

[0124] "Overstocked items" refers to items that are overstocked in a store.

[0125] "Plus one products" refer to complementary products such as beverages and snacks that are suggested for addition to the main shopping list based on the user's purchase history and preference information.

[0126] "Sales floor guide" refers to information indicating where in the store the food ingredients that the user is trying to purchase are located.

[0127] This invention is a system that reduces food waste and improves the consumer's shopping experience by generating optimal recipes based on user and store information and presenting them to the user. This system is composed of multiple components, including a user terminal, a server, and a database, and operates as follows:

[0128] System Configuration

[0129] This system consists of a user terminal, a server, and a database. The user terminal is a smartphone or tablet, and is the device through which the user inputs and receives information into the system. The server runs programs including the generative AI model and plays a central role in data analysis and recipe generation. The database stores user information and store information, and the server accesses it to obtain the necessary information.

[0130] Obtaining user information

[0131] A user logs into the "Smart Basket" app and enters information such as family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the user's device to the server. The server stores the received user information in a database and creates and updates the user profile.

[0132] Obtaining store information

[0133] The server calls the API at regular intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained information is analyzed by the server and stored in a database.

[0134] Recipe Generation

[0135] The server uses a generative AI model to generate optimal recipes based on user and store information. The recipe manager GPT creates recipes taking into account the user profile and store inventory. The generated recipe candidates are stored in a database.

[0136] Recipe presentation and product information

[0137] The user's device displays a notification of the recipe suggestion to the user. When the user confirms the notification and opens the app to check the suggested recipe, the user's device displays the recipe details (ingredients, cooking instructions) and information about where to buy the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the user's device.

[0138] Proposal for unsold products

[0139] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates a new recipe that prioritizes the use of the identified products and notifies the user's device.

[0140] Plus One Proposal

[0141] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information. It then generates a suggestion message and sends it to the user's device. The user can then review the suggested "plus one" items and choose whether to add them to their shopping list.

[0142] Specific examples

[0143] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[0144] 2. The device sends this information to the server, which updates the user profile.

[0145] 3. The server retrieves the store information and stores it in the database.

[0146] 4. The server calls the recipe GPT, generates a "Japanese food recipe", and saves it. An example prompt is as follows:

[0147] "Generate recipes using mackerel, Chinese cabbage, and tofu for a user who likes Japanese food but has an egg allergy."

[0148] 5. The device notifies user A of the recipe suggestion and displays details and sales area information.

[0149] 6. The server regenerates and suggests recipes using ingredients that are close to their expiration date.

[0150] 7. The device suggests additional items such as green tea and Japanese sweets to User A.

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

[0152] Step 1: Enter your user information

[0153] A user logs in to the "Smart Basket" app and enters information such as family composition, food preferences, budget, cooking experience, and health condition. The information entered includes the user's family composition (e.g., a family of three), food preferences (e.g., likes Japanese food), budget (e.g., 5,000 yen per week), cooking experience (e.g., intermediate), and health condition (e.g., egg allergy).

[0154] The terminal sends the input information to the server in JSON format. Here, input is the information the user enters into the terminal, and output is the JSON data sent to the server.

[0155] Step 2: Save user information

[0156] The server saves the received user information in the database. Specifically, it parses the JSON data received on the server side and inserts it into the "user_profiles" table.

[0157] Input: JSON data sent from the terminal

[0158] Output: Save data to database

[0159] Step 3: Get store information

[0160] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. Specifically, the server uses a Cron job to periodically send an HTTP GET request to the store API.

[0161] Input: API request via Cron job

[0162] Output: Obtain store information data

[0163] Step 4: Save your store information

[0164] The server analyzes the acquired store information and stores it in a database. For example, it stores inventory information in the "inventory" table.

[0165] Input: Acquired store information data

[0166] Output: Save data to database

[0167] Step 5: Generate the recipe

[0168] The server generates an optimal recipe using a generative AI model (e.g., GPT-3 (registered trademark)) based on user information and store information. A prompt such as "Please generate a recipe using mackerel, Chinese cabbage, and tofu for a user who likes Japanese food but has an egg allergy" is used.

[0169] Input: User information and store information

[0170] Output: Generated recipe data

[0171] Step 6: Save the recipe

[0172] The server saves the generated recipe information to a database. Specifically, it inserts the recipes returned by the generative AI model into the "recipes" table.

[0173] Input: Generated recipe data

[0174] Output: Save data to database

[0175] Step 7: Recipe Suggestion Notifications

[0176] The device displays a recipe suggestion notification to the user, for example, by sending a push notification using Firebase Cloud Messaging.

[0177] Input: Recipe suggestion data from the server

[0178] Output: Push notification to the user

[0179] Step 8: View Recipe Details

[0180] When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and where to buy those ingredients. For example, the information is displayed in HTML format on the recipe details screen within the app.

[0181] Input: Recipe suggestion notification that the user confirmed in the app

[0182] Output: Recipe details

[0183] Step 9: Generate a shopping list

[0184] When a user selects a recipe, a shopping list is automatically generated and displayed on the user's terminal, for example, a list of ingredients for the selected recipe.

[0185] Input: User's recipe selection

[0186] Output: Auto-generated shopping list

[0187] Step 10: Identifying products with approaching expiration dates and generating recipes

[0188] The server identifies products that are close to their expiration date or are in excess of stock from store information, and prioritizes regenerating recipes that use these products. For example, it uses an SQL query to extract products that are close to their expiration date from the "inventory" table.

[0189] Input: Store inventory information

[0190] Output: Recipe data based on products with an approaching expiration date

[0191] Step 11: Regenerated Recipe Suggestion

[0192] The device notifies the user of the regenerated recipe, for example by sending a push notification.

[0193] Input: Regenerated recipe data

[0194] Output: Push notification to the user

[0195] Step 12: Propose a Plus One Product

[0196] The server identifies plus-one products based on the user's purchase history and preference information, generates a recommendation message, and sends it to the user's device. For example, the server identifies recommended products using a machine learning model.

[0197] Input: User purchase history and preference information

[0198] Output: Plus one product suggestion message

[0199] Step 13: Check and add your Plus One items

[0200] The user checks the suggested plus-one items and selects whether to add them to the shopping list. The terminal updates the shopping list according to the user's selection.

[0201] Input: Plus One product suggestion message

[0202] Output: Updated shopping list

[0203] (Application example 1)

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

[0205] Conventional systems have difficulty proposing optimal recipes based on a user's individual preferences and household circumstances, and have been inadequate in proposing recipes that utilize products that are nearing their expiration date or that are overstocked. It has also been difficult to appropriately suggest "plus-one" products or promotional products, resulting in insufficient reduction of food waste and insufficient sales promotion. Furthermore, there is no in-store guidance to help users efficiently purchase the ingredients they need, which has led to inefficient shopping.

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

[0207] In this invention, the server includes a means for inputting user information, a means for acquiring store information, a means for generating a recipe based on the user information and the store information, a means for generating an optimal recipe using a generative AI model, a means for generating a prompt and acquiring a recipe, a means for presenting the generated recipe to the user, and a means for providing information on ingredients needed from the recipe. This allows for optimal recipe suggestions based on the user's preferences and health status. Furthermore, the server can suggest recipes using products with approaching expiration dates or overstocked items, as well as appropriate suggestions for additional products and advertised items, effectively reducing food waste and promoting sales. Furthermore, the server provides in-store guidance to help users efficiently purchase the ingredients they need, improving shopping efficiency.

[0208] "User information" is personal data such as the user's family structure, food preferences, budget, cooking experience, and health condition.

[0209] "Store information" refers to data about the store, such as store inventory, prices, expiration dates, and featured products.

[0210] The "recipe generation means" refers to a program or algorithm for creating an appropriate recipe based on user information and store information.

[0211] A "generative AI model" is a technology for generating text and information using large-scale language models and generative artificial intelligence.

[0212] A "prompt" is a question or instruction written in a specific format to be input into a generative AI model.

[0213] A "generated recipe" is a cooking procedure and ingredient list created by a generative AI model that takes into account user and store information.

[0214] The "user presentation means" refers to a device or software for displaying the generated recipe to the user.

[0215] The "ingredient guide means" is a system or method for informing the user of the location in the store of ingredients required for a recipe and a shopping list.

[0216] This invention is a system that generates optimal recipes based on user information and store information and presents them to consumers. The purpose of this system is to reduce food waste and promote sales. This system, "Smart Basket," consists of a user terminal, a server, and a database, and is specifically configured as follows:

[0217] System Configuration

[0218] User terminal

[0219] A user device refers to a device such as a smartphone or tablet. The user uses this device to access the application and enter information such as family composition, food preferences, budget, cooking experience, and health status. The entered user information is sent from the device to the server.

[0220] server

[0221] The server receives information sent from the user's device and stores it in a database. It also periodically calls an API to obtain store information such as store inventory, prices, expiration dates, and featured products. The server also calls the generative AI model and generates recipes.

[0222] Database

[0223] The database stores user and store information. The server accesses this database to obtain the necessary information and uses it to generate recipes.

[0224] Program processing

[0225] Obtaining user information

[0226] The user logs in to the app and enters the necessary information (family composition, food preferences, budget, cooking experience, health condition, etc.). The user's device sends the entered information to the server.

[0227] Obtaining store information

[0228] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained information is analyzed and stored in a database.

[0229] Generating recipe candidates

[0230] The server generates a recipe by calling a generative AI model based on the user and store information. This AI model generates the optimal recipe taking into account the user profile (e.g., "likes Japanese food") and the store's inventory (e.g., mackerel, Chinese cabbage, tofu). An example of this prompt is as follows:

[0231] User profile: {'family': 'Family of 4', 'food_pref': 'Japanese food', 'budget': '5000 yen', 'cooking_experience': 'Intermediate', 'health_status': 'None in particular'}

[0232] Store inventory: {'Mackerel': '10', 'Chinese cabbage': '15', 'Tofu': '20', 'Green onion': '25', 'Soy sauce': '30'}

[0233] Use this information to generate the best recipe possible.

[0234] Recipe presentation and product information

[0235] The user's device will display a notification of the suggested recipe to the user. When the user opens the app and checks the suggested recipe, the device will display the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list will be automatically generated and displayed on the device.

[0236] Proposal for unsold products

[0237] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize these items. Recipes based on this information are also suggested to the user on their device.

[0238] Plus One Proposal

[0239] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the "plus one" item suggestion to the user, who can then choose whether to add it to their shopping list.

[0240] Advertisement product proposals

[0241] When a food manufacturer provides advertising campaign information to the server, the server invokes the generative AI model to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[0242] This allows users to find the most suitable recipes, making shopping more efficient and eco-friendly. It also offers appropriate suggestions for plus-one products and promotional items, which is expected to have a positive effect on sales promotion.

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

[0244] Step 1:

[0245] A user logs in to the application using a smartphone device. The user enters user information such as family composition, food preferences, budget, cooking experience, and health condition. This user information set is entered into the device and sent as is to the server. The input data is packaged in JSON format or similar and sent to the server via a secure API.

[0246] Step 2:

[0247] The server analyzes the user information received via a secure API and stores it in a database. It analyzes the received data to generate a user profile and stores the profile information in a database, making the user information available for subsequent processing.

[0248] Step 3:

[0249] The server calls the API at specific time intervals to obtain store information such as store inventory, prices, expiration dates, and featured products. This obtains the latest store information. The obtained store information is then retrieved again through a secure API, and the server analyzes the data and saves it in a database. This saves the latest information on inventory, prices, expiration dates, etc.

[0250] Step 4:

[0251] The server generates a recipe by calling the generative AI model based on the user information and store information. It then generates a prompt for the generative AI model and sends a request to the AI ​​using that prompt. For example, it generates the following prompt:

[0252] User profile: {'family': 'Family of 4', 'food_pref': 'Japanese food', 'budget': '5000 yen', 'cooking_experience': 'Intermediate', 'health_status': 'None in particular'}

[0253] Store inventory: {'Mackerel': '10', 'Chinese cabbage': '15', 'Tofu': '20', 'Green onion': '25', 'Soy sauce': '30'}

[0254] Use this information to generate the best recipe possible.

[0255] The server analyzes the generated recipe and stores it in a database.

[0256] Step 5:

[0257] The user's device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients (location in the store) to the user. The input data is the recipe information selected by the user, and the output data is the specific cooking steps, shopping list, and in-store directions.

[0258] Step 6:

[0259] The server identifies products that are close to their expiration date or are in excess of stock from store information, and regenerates recipes that prioritize the use of these products. This generates recipes that can utilize products that are close to their expiration date or are in excess of stock, and sends them to the terminal. The user is also notified again.

[0260] Step 7:

[0261] The server identifies plus-one items such as beverages and confectionery based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the suggested plus-one items to the user and allows them to choose whether to add them to their shopping list. If the user chooses to add them, the information is sent to the server and the shopping list is updated.

[0262] Step 8:

[0263] When a food manufacturer provides advertising campaign information to the server, the server invokes the generative AI model to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipe and displays it to encourage them to purchase it. If the user adds the advertised product to their shopping list, that information is sent to the server and the shopping list is updated.

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

[0265] This invention is a system that reduces food waste and promotes sales by generating optimal recipes based on user information and store information, and then using an emotion engine to make suggestions based on the user's emotions. Specifically, this system is configured and operates as follows.

[0266] System Configuration

[0267] This system, "Smart Basket," consists of a user device, a server, a database, and an emotion engine. The user device is a smartphone or tablet, which communicates with the server to send and receive information. The server runs a program incorporating generative AI and an emotion engine to generate recipes and analyze user emotions. User information and store information is stored in the database, which the server accesses to obtain the necessary information.

[0268] Program processing

[0269] Obtaining user information

[0270] Users log in to the "Smart Basket" app and enter information such as family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to the server, which stores it in a database and creates a user profile.

[0271] Obtaining store information

[0272] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database.

[0273] Generating recipe candidates

[0274] The server generates a recipe by calling the recipe GPT based on the user and store information. The recipe GPT takes into account the user profile (e.g., likes Japanese food, has an egg allergy) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate the optimal recipe. The generated recipe candidates are stored in a database.

[0275] Emotion recognition and recipe adjustment

[0276] The device collects emotional data from the user's facial expressions and voice. The emotion engine analyzes this data and identifies the user's current emotion (e.g., joy, sadness, stress). The server adjusts the recipe based on the acquired emotional data and makes suggestions according to the user's emotions.

[0277] Recipe presentation and product information

[0278] The device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[0279] Proposal for unsold products

[0280] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize the use of the identified products. Recipes based on this information are also suggested to the user on the device.

[0281] Plus One Proposal

[0282] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history, preference information, and emotional data, and generates a suggestion message that it sends to the device. The device then displays the "plus one" item suggestions to the user, who can then choose whether to add them to their shopping list.

[0283] Advertisement product proposals

[0284] When a food manufacturer provides advertising campaign information to the server, the server calls the recipe GPT to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[0285] Specific examples

[0286] Example 1: Customer A's case

[0287] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[0288] 2. The device sends the input information to the server, which updates the user profile.

[0289] 3. The server retrieves the store information and stores it in the database.

[0290] 4. The server calls the recipe GPT to generate and save a "Japanese food recipe."

[0291] 5. The device collects user A's emotion data and sends it to the server.

[0292] 6. The emotion engine analyzes User A's emotions and determines, for example, that he is under high stress.

[0293] 7. Based on the emotional data obtained, the server adjusts and suggests recipes suitable for reducing stress.

[0294] 8. The device provides recipes, displays shopping lists and store directions.

[0295] 9. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[0296] 10. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[0297] Example 2: Advertising

[0298] 1. Food manufacturers provide information about new products to a server.

[0299] 2. The server calls the recipe GPT to generate a recipe containing the advertised product.

[0300] 3. The server saves the generated recipe in the database.

[0301] 4. The device collects user B's emotion data and sends it to the server.

[0302] 5. The emotion engine analyzes User B's emotions and determines that, for example, they are feeling a high level of joy.

[0303] 6. The server adjusts and proposes recipes for advertising products based on the obtained emotional data.

[0304] 7. The device notifies User B of the recipe that includes the advertised item. User B adds the suggested item to their shopping list.

[0305] The processing flow will be explained below.

[0306] Step 1:

[0307] The user logs in to the "Smart Basket" app.

[0308] Step 2:

[0309] The device prompts the user to enter information such as family composition, food preferences, budget, cooking experience, and health status.

[0310] Step 3:

[0311] The terminal transmits the input user information to the server.

[0312] Step 4:

[0313] The server stores the received user information in a database and updates the user profile.

[0314] Step 5:

[0315] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc.

[0316] Step 6:

[0317] The server analyzes the store information it has acquired and processes it as necessary (e.g., standardizing date formats, cleaning data).

[0318] Step 7:

[0319] The server stores the analyzed store information in a database.

[0320] Step 8:

[0321] The server calls the recipe manager GPT based on the user information and store information to generate a recipe.

[0322] Step 9:

[0323] The recipe GPT takes into account the user profile (e.g., likes Japanese food, allergy to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate optimal recipe candidates.

[0324] Step 10:

[0325] The server stores the generated recipes in a database for each user.

[0326] Step 11:

[0327] The device collects emotional data from the user's facial expressions, voice, etc.

[0328] Step 12:

[0329] The device transmits the collected emotion data to a server.

[0330] Step 13:

[0331] The emotion engine analyzes the user's emotion data to identify their current emotional state (e.g., joy, sadness, stress).

[0332] Step 14:

[0333] The server adjusts the recipe based on the obtained emotional data and selects the optimal recipe according to the user's emotions.

[0334] Step 15:

[0335] The device displays a notification of the tailored recipe suggestions to the user.

[0336] Step 16:

[0337] The user opens the app and sees the suggested recipes.

[0338] Step 17:

[0339] The device displays the recipe details (ingredients, instructions) and the location of the ingredients (location within the store) to the user.

[0340] Step 18:

[0341] Users select their favorite recipes and add them to their shopping list.

[0342] Step 19:

[0343] The server identifies products that are close to their expiration date or that are in excess of stock from store information.

[0344] Step 20:

[0345] The server calls the recipe manager GPT again to generate a recipe that prioritizes the use of the identified products.

[0346] Step 21:

[0347] Recipe GPT generates recipes using these products.

[0348] Step 22:

[0349] The server updates the recipe database to suggest the generated recipes to the user.

[0350] Step 23:

[0351] The device notifies the user of suggestions for additional products (e.g., drinks or sweets).

[0352] Step 24:

[0353] The server obtains the information about the advertised products and calls the recipe GPT to generate a recipe that includes the advertised products.

[0354] Step 25:

[0355] Recipe GPT generates recipes that include the advertised products.

[0356] Step 26:

[0357] The server stores the advertised recipes in a database and suggests them to users who meet certain conditions.

[0358] Step 27:

[0359] The terminal notifies the user of the advertised recipe and encourages them to make a purchase.

[0360] Example 2

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

[0362] In today's consumer society, there is a need to efficiently reduce food waste and increase consumer purchasing power, but to achieve this, it is necessary to make proposals that respond to the diverse needs and emotions of consumers.In addition, it is also important to reflect store inventory information in real time, appropriately utilize products that are approaching their expiration date, and efficiently promote advertised products.

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

[0364] In this invention, the server includes means for inputting user information, means for acquiring store information, means for generating recipes based on the user information and the store information, means for presenting the generated recipes to the user, means for suggesting ingredients needed from the recipes, means for collecting emotion data, means for analyzing the collected emotion data and adjusting the recipes based on the user's emotion, and means for suggesting plus-one products based on the user's purchase history and preference information. This makes it possible to provide appropriate recipe suggestions and purchasing processes according to the needs and emotions of each user, thereby effectively reducing food waste and promoting sales.

[0365] "User information" is personal data of the user, including family composition, food preferences, budget, cooking experience, health condition, and the like.

[0366] "Store information" is data obtained from the store, and includes inventory information, prices, expiration dates, featured products, and the like.

[0367] A "recipe" is a list of instructions and ingredients for preparing a particular dish or meal.

[0368] "Emotion data" is data that indicates the psychological state of the user, obtained from facial expressions, voice, etc.

[0369] "Plus one product" refers to an additional product such as a drink or snack that is suggested in addition to the product that the user is primarily intending to purchase.

[0370] "Advertised products" are products that are the subject of a specific campaign and are proposed by companies or manufacturers for promotional purposes.

[0371] An "emotion engine" refers to a program or function that analyzes emotional data collected from a user and identifies the user's psychological state.

[0372] A "generative AI model" refers to an artificial intelligence algorithm that generates appropriate output based on input data.

[0373] An "API" is an interface that allows applications to connect with other services and databases.

[0374] "Database" refers to a structured collection of data for efficiently storing and managing data used within a system.

[0375] A "terminal" is a device that a user can directly operate, and includes a smartphone, tablet, etc.

[0376] A "server" refers to a combination of a computer and software for managing the entire system and processing data.

[0377] This invention is a recipe suggestion system for reducing food waste and promoting sales, and is composed of a user terminal, a server, a database, and an emotion engine. This system automatically collects user information, acquires store information, and generates optimal recipes based on this information and suggests them to the user.

[0378] Registering user information

[0379] Users log in to the "Smart Basket" app from their smartphones, tablets, or other devices and enter information such as their family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the device to the server, which then stores the received information in a database and creates a user profile.

[0380] Obtaining store information

[0381] The server uses the API at specific intervals (e.g., every hour) to retrieve store inventory information, prices, expiration dates, featured products, etc. The retrieved information is analyzed by the server and stored in a database. This data is later used to generate recipes.

[0382] Generating recipe candidates

[0383] The server calls the generative AI model (GPT for recipes) based on the user profile and store information to generate the optimal recipe. For example, if a user prefers Japanese food but is allergic to eggs, the generative AI model will generate recipes using mackerel, Chinese cabbage, and tofu based on the store's inventory. The generated recipe candidates are saved in a database.

[0384] Emotion recognition and recipe adjustment

[0385] The device collects emotional data from the user's facial expressions and voice and sends it to the server. The server then uses an emotion engine to analyze the emotional data and identify the user's current emotional state. For example, if the user is feeling stressed, the server adjusts the recipes it has generated and suggests recipes that are suitable for reducing stress.

[0386] Recipe presentation and product information

[0387] The device displays a notification of the recipe suggestion to the user. When the user confirms the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[0388] Proposal for unsold products

[0389] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and regenerates recipes that prioritize these items. This new recipe is also suggested to the user on their device.

[0390] Plus one product proposal

[0391] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history, preference information, and emotional data. The generated suggestion message is sent from the server to the terminal, and the "plus one" item suggestion is displayed to the user. The user can choose whether to add it to their shopping list.

[0392] Advertisement product proposals

[0393] When a food manufacturer provides information about a new product to the server, the server invokes a generative AI model (GPT for recipes) to generate a recipe that includes the advertised product. This new recipe is then provided to users who meet certain conditions. The device notifies the user of the advertised recipe, allowing them to consider purchasing it.

[0394] Specific examples

[0395] Example 1: Customer A's case

[0396] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[0397] 2. The device sends the input information to the server, which updates the user profile.

[0398] 3. The server retrieves the store information and stores it in the database.

[0399] 4. The server calls the generative AI model (GPT for recipes) to generate and save a "Japanese food recipe."

[0400] 5. The device collects user A's emotion data and sends it to the server.

[0401] 6. The emotion engine analyzes User A's emotions and determines, for example, that he is under high stress.

[0402] 7. Based on the emotional data obtained, the server adjusts and suggests recipes suitable for reducing stress.

[0403] 8. The device provides recipes, displays shopping lists and store directions.

[0404] 9. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[0405] 10. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[0406] Prompt Sentence Examples

[0407] 1. Basic recipe generation:

[0408] "Generate new recipes taking into account the user profile (e.g., I like Japanese food, I'm allergic to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu)."

[0409] 2. Adjust recipes according to emotions:

[0410] "Generate relaxing Japanese food recipes for users who are under a lot of stress."

[0411] 3. Disposal of unsold items:

[0412] "Please generate recipes using products that are close to their expiration date (e.g., tofu, mackerel)."

[0413] 4. Recipes containing the advertised product:

[0414] "Generate recipes that include new products from food manufacturers (e.g., specific seasonings)."

[0415] This system provides recipe suggestions and purchasing processes that respond to users' diverse needs and emotions, making it possible to effectively reduce food waste and promote sales.

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

[0417] Step 1: Register user information

[0418] Users log in to the app from a device such as a smartphone or tablet and enter information such as their family composition, food preferences, budget, cooking experience, and health condition. The entered information is sent from the device to the server. The server stores the received information in a database and creates a user profile. This enables the system to suggest recipes tailored to each individual user. The input is a form of user information, and the output is the user profile in the database.

[0419] Step 2: Get store information

[0420] The server uses the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database. This data is later used for recipe generation and inventory management. The input is the API response, and the output is the store information in the database.

[0421] Step 3: Generate recipe candidates

[0422] The server calls the generative AI model (GPT for recipes) based on the user profile and store information to generate the optimal recipe. For example, if the user prefers Japanese food and is allergic to eggs, the generative AI model will generate a recipe using mackerel, Chinese cabbage, and tofu based on the store's inventory. The generated recipe candidates are stored in a database. The input is user and store data, and the output is the generated recipe.

[0423] Step 4: Emotion recognition and recipe adjustment

[0424] The device collects emotional data from the user's facial expressions and voice and sends it to the server. The server then uses an emotion engine to analyze the emotional data and identify the user's current emotional state. For example, if the user is feeling stressed, the server adjusts the recipes it has generated and suggests recipes that are suitable for reducing stress. The input is facial expressions and voice, and the output is the user's emotional state.

[0425] Step 5: Present the recipe and introduce the product

[0426] The device displays a notification of a recipe suggestion to the user. When the user confirms the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the device. The input is the user's selection, and the output is the display content and the shopping list.

[0427] Step 6: Propose unsold items

[0428] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and regenerates recipes that prioritize these items. These new recipes are also suggested to users on their devices. This allows for products with low demand to be sold. The input is stock information, and the output is the regenerated recipe.

[0429] Step 7: Propose a Plus One Product

[0430] The server identifies plus-one products such as beverages and confectionery based on the user's purchase history, preference information, and emotional data. The generated suggestion message is sent from the server to the terminal, and the plus-one product suggestion is displayed to the user. The user can choose whether to add this to their shopping list. The input is the purchase history and emotional data, and the output is the suggestion message.

[0431] Step 8: Propose advertising products

[0432] When a food manufacturer provides information about new products and advertising campaigns to the server, the server calls a generative AI model (GPT for recipes) to generate recipes that include the advertised products based on that information. These new recipes are then provided to users who meet certain conditions. The device notifies the user of the advertised recipe, allowing them to consider purchasing it. The input is new product information, and the output is a recipe that includes the advertisement.

[0433] (Application example 2)

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

[0435] Conventional recipe suggestion systems suggest recipes based on a user's food preferences and health status, but do not take into account emotions or real-time store information, which limits their effectiveness in increasing user satisfaction and reducing food waste. This invention solves the problem of more effectively reducing food waste and promoting sales by generating and suggesting optimal recipes based on the user's emotions and real-time store information.

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

[0437] In this invention, the server includes means for inputting user information, means for acquiring store information, means for generating a recipe based on the user information and the store information, means for presenting the generated recipe to the user, means for indicating ingredients needed from the recipe, means for recognizing the user's emotions, and means for adjusting the recipe in accordance with the emotions. This makes it possible to propose optimal recipes taking the user's emotions into consideration, thereby improving user satisfaction, reducing food waste, and promoting store sales.

[0438] "User information" refers to information entered by the user, such as family composition, food preferences, budget, cooking experience, and health condition.

[0439] "Store information" refers to information acquired in real time, such as store inventory, prices, expiration dates, and featured products.

[0440] A "recipe" is a list of cooking procedures and necessary ingredients generated based on user information and store information.

[0441] "User's emotion" refers to an emotional state recognized from the user's facial expression, voice, etc., and includes, for example, joy, sadness, stress, etc.

[0442] An "emotion engine" is software or hardware for analyzing a user's emotion data and identifying the user's current emotion.

[0443] A "smartphone" is a portable communication device that a user uses to run applications.

[0444] "Generative AI" is an artificial intelligence model that generates optimal recipes based on user and store information.

[0445] "Navigation" is a function that provides directions for users to obtain the ingredients they need within the store.

[0446] The present invention is a system that generates optimal recipes based on "user information" and "store information," and then uses an "emotion engine" to make suggestions based on the user's emotions. The system is composed of a user terminal, a server, and a database, and is operated using a smartphone application. Specific embodiments are described below.

[0447] System Configuration

[0448] User terminal

[0449] The user device is primarily a smartphone. Once the user installs the app and logs in, they can input and save their "user information" such as their family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to a server and stored in a database.

[0450] server

[0451] The server is the main component that runs the program, which includes the following functions:

[0452] 1. Saving user information: The server saves the user information sent from the user terminal in a database and creates a user profile.

[0453] 2. Obtaining store information: The server periodically obtains "store information" such as store inventory, prices, expiration dates, and featured products through the API and stores it in a database.

[0454] 3. Recipe generation: The server generates the optimal recipe using a "generative AI model" based on user and store information. For example, OpenAI's GPT-4 (registered trademark) is used for generation.

[0455] 4. Emotion analysis: The server analyzes the emotion data sent from the user's device using an "emotion engine" to identify the user's current emotion.

[0456] 5. Recipe adjustment: Based on the emotional data, the optimal recipe is readjusted and suggested to the user.

[0457] Database

[0458] The database stores and manages user information, store information, generated recipes, and the like.

[0459] Operation procedure and data processing flow

[0460] 1. Enter and save user information

[0461] The user logs in to the smartphone application and enters the required information.

[0462] The entered information is sent from the terminal to the server and stored in a database.

[0463] 2. Obtaining store information

[0464] The server periodically retrieves store inventory and price information from the API.

[0465] Save the acquired store information in the database.

[0466] 3. Recipe generation and suggestions

[0467] The server calls a generative AI model based on user information and store information and generates a recipe.

[0468] The generated recipes are stored in a database and suggested to users.

[0469] 4. Sentiment analysis and recipe adjustment

[0470] The emotion engine analyzes emotions based on facial expressions and voice data sent from the user's device.

[0471] Based on the obtained emotional data, the server readjusts the recipe and presents it to the user.

[0472] Specific examples

[0473] Example 1: Customer A's case

[0474] 1. User A logs in to the smartphone app and enters their food preferences and health status.

[0475] 2. The server retrieves the store's inventory information and stores it in a database.

[0476] 3. The server uses the generative AI model to generate a "Japanese food recipe."

[0477] 4. Analyze the user's emotional data (e.g., stress) and adjust the recipe accordingly.

[0478] 5. The smartphone app suggests the best recipe for User A and provides guidance on where to buy the necessary ingredients.

[0479] Prompt Sentence Examples

[0480] User Profile:

[0481] I like Japanese food

[0482] Egg allergy

[0483] I feel stressed easily recently

[0484] Store inventory information:

[0485] The mackerel is fresh

[0486] Abundant Chinese cabbage

[0487] There is little tofu left

[0488] Generate the recipe:

[0489] Contains ingredients that help reduce stress

[0490] Easy to cook

[0491] It is Japanese food

[0492] Based on this prompt, the generative AI model generates an appropriate recipe and suggests it to the user. This embodiment makes it possible to suggest optimal recipes that take the user's emotions into consideration, thereby improving user satisfaction, reducing food waste, and promoting store sales.

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

[0494] Step 1:

[0495] A user logs in to the smartphone app and enters user information such as family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the device to the server, which then stores it in a database. This creates a user profile.

[0496] Input: User information (family composition, food preferences, budget, cooking experience, health condition)

[0497] Output: User profile stored in the database

[0498] Specific operation: Enter user information into the input form on the smartphone app screen and press the send button. The input information is sent to the server and saved in the database.

[0499] Step 2:

[0500] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained store information is analyzed by the server and stored in a database.

[0501] Input: Store information API

[0502] Output: Store information saved in the database

[0503] Specific operation: A program on the server periodically calls the store information API, analyzes the acquired data, and stores it in a database.

[0504] Step 3:

[0505] The server calls the generative AI model based on user and store information to generate optimal recipes. The generated recipes are stored in a database and presented to the user as needed.

[0506] Input: User profile, store information

[0507] Output: Generated recipe (stored in database)

[0508] Specific operation: The server inputs user information and store information into the generative AI model to generate prompt text. The generative AI model then generates the optimal recipe and stores the results in a database.

[0509] Step 4:

[0510] The user device uses a camera and microphone to collect facial and voice data from the user and transmits it to the server, which then uses an emotion engine to analyze this data and determine the user's current emotion.

[0511] Input: User's facial expression data, voice data

[0512] Output: Parsed emotion data

[0513] Specific operation: The user takes a facial expression in front of the smartphone camera or speaks into the microphone. This data is sent to the server and analyzed by the emotion engine.

[0514] Step 5:

[0515] The server readjusts the optimal recipe based on the analyzed emotional data. The readjusted recipe is sent to the user's device and presented to the user. This allows the server to suggest recipes that match the user's current emotions.

[0516] Input: emotion data, existing recipes

[0517] Output: Reworked recipe

[0518] Specific operation: The server analyzes the emotion data, regenerates or adjusts the recipe, and sends the results to the user's smartphone, where the recipe is displayed.

[0519] Step 6:

[0520] The user device automatically generates a shopping list based on the optimal recipe, and also provides navigation to the store and guides the user to the location of the ingredients they need.

[0521] Input: Reworked recipe

[0522] Output: Purchase list, store information

[0523] Specific operation: When the user views the recipe display screen of the app, a shopping list is automatically generated. The app displays the route to the sales floor and begins navigation.

[0524] Step 7:

[0525] The server identifies products that are nearing their expiration date or are in excess of stock from the store's inventory information, and generates recipes using these products. The generated recipes are sent to the user's terminal and presented as additional suggestions.

[0526] Input: Store information

[0527] Output: Inventory adjustment recipe

[0528] Specific operation: The server analyzes store information and sends prompt text to the generation AI model, prioritizing products with an approaching expiration date or overstocked items. The generated recipe is then presented to the user.

[0529] Step 8:

[0530] The server suggests additional products, such as beverages and snacks, based on the user's purchase history, preference information, and emotional data. A suggestion message is sent to the user's terminal, and the user can choose whether to add the product to their shopping list.

[0531] Input: purchase history, preference information, emotional data

[0532] Output: Additional product suggestions

[0533] Specific operation: The server analyzes purchase history and preference information, generates a list of additional products based on emotional data, and sends the list to the user's device to suggest additional purchases.

[0534] Prompt Sentence Examples

[0535] Here is an example prompt:

[0536] User Profile:

[0537] I like Japanese food

[0538] Egg allergy

[0539] I feel stressed easily recently

[0540] Store inventory information:

[0541] The mackerel is fresh

[0542] Abundant Chinese cabbage

[0543] There is little tofu left

[0544] Generate the recipe:

[0545] Contains ingredients that help reduce stress

[0546] Easy to cook

[0547] It is Japanese food

[0548] This allows for the generation of optimal recipes that take into account the user's emotions and store inventory information, reducing food waste and improving user satisfaction.

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

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

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

[0552] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0565] The present invention is a system that reduces food waste and promotes sales by generating optimal recipes based on user information and store information and presenting them to consumers. Specifically, this system is configured and operates as follows.

[0566] System Configuration

[0567] This system, "Smart Basket," consists of a user device, a server, and a database. The user device is a smartphone or tablet, which communicates with the server to send and receive information. The server runs a program incorporating generative AI to generate recipes and analyze data. User information and store information is stored in the database, which the server accesses to retrieve the necessary information.

[0568] Program processing

[0569] Obtaining user information

[0570] Users log in to the "Smart Basket" app and enter information such as family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to the server, which stores it in a database and creates a user profile.

[0571] Obtaining store information

[0572] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database.

[0573] Generating recipe candidates

[0574] The server generates a recipe by calling the recipe GPT based on the user and store information. The recipe GPT takes into account the user profile (e.g., likes Japanese food, has an egg allergy) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate the optimal recipe. The generated recipe candidates are stored in a database.

[0575] Recipe presentation and product information

[0576] The device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[0577] Proposal for unsold products

[0578] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize the use of the identified products. Recipes based on this information are also suggested to the user on the device.

[0579] Plus One Proposal

[0580] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the "plus one" item suggestion to the user, who can then choose whether to add it to their shopping list.

[0581] Advertisement product proposals

[0582] When a food manufacturer provides advertising campaign information to the server, the server calls the recipe GPT to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[0583] Specific examples

[0584] Example 1: Customer A's case

[0585] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[0586] 2. The device sends the input information to the server, which updates the user profile.

[0587] 3. The server retrieves the store information and stores it in the database.

[0588] 4. The server calls the recipe GPT to generate and save a "Japanese food recipe."

[0589] 5. The device provides the recipe to user A and displays a shopping list and store information.

[0590] 6. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[0591] 7. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[0592] Example 2: Advertising

[0593] 1. Food manufacturers provide information about new products to a server.

[0594] 2. The server calls the recipe GPT to generate a recipe containing the advertised product.

[0595] 3. The server saves the generated recipe in the database.

[0596] 4. The device notifies User B of the recipe that includes the advertised product. User B adds the suggested product to their shopping list.

[0597] The processing flow will be explained below.

[0598] Step 1:

[0599] The user logs in to the "Smart Basket" app.

[0600] Step 2:

[0601] The device prompts the user to enter information such as family composition, food preferences, budget, cooking experience, and health status.

[0602] Step 3:

[0603] The terminal transmits the input user information to the server.

[0604] Step 4:

[0605] The server stores the received user information in a database and updates the user profile.

[0606] Step 5:

[0607] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc.

[0608] Step 6:

[0609] The server analyzes the store information it has acquired and processes it as necessary (e.g., standardizing date formats, cleaning data).

[0610] Step 7:

[0611] The server stores the analyzed store information in a database.

[0612] Step 8:

[0613] The server calls the recipe manager GPT based on the user information and store information to generate a recipe.

[0614] Step 9:

[0615] The recipe manager, GPT, takes into account the customer profile (e.g., likes Japanese food, allergy to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate optimal recipe candidates.

[0616] Step 10:

[0617] The server stores the generated recipes in a database for each user.

[0618] Step 11:

[0619] The terminal displays a notification of the recipe suggestion to the user.

[0620] Step 12:

[0621] The user opens the app and sees the suggested recipes.

[0622] Step 13:

[0623] The device displays the recipe details (ingredients, instructions) and the location of the ingredients (location within the store) to the user.

[0624] Step 14:

[0625] Users select their favorite recipes and add them to their shopping list.

[0626] Step 15:

[0627] The server identifies products that are nearing expiration dates or are overstocked.

[0628] Step 16:

[0629] The server calls the recipe manager GPT again to generate a recipe that prioritizes the use of the identified products.

[0630] Step 17:

[0631] Recipe GPT generates recipes using these products.

[0632] Step 18:

[0633] The server updates the recipe database to suggest the generated recipes to the user.

[0634] Step 19:

[0635] The device notifies the user of suggestions for additional products (e.g., drinks or sweets).

[0636] Step 20:

[0637] The server obtains the information about the advertised products and calls the recipe GPT to generate a recipe that includes the advertised products.

[0638] Step 21:

[0639] Recipe GPT generates recipes that include the advertised products.

[0640] Step 22:

[0641] The server stores the advertised recipes in a database and suggests them to users who meet certain conditions.

[0642] Step 23:

[0643] The terminal notifies the user of the advertised recipe and encourages them to make a purchase.

[0644] Example 1

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

[0646] In today's food market, food waste due to expired or unsold products is a major problem. In addition, inventory management in stores is becoming increasingly complex, and there is a lack of information available to help consumers purchase ingredients efficiently. Furthermore, the need for recipe suggestions tailored to consumers' preferences and health conditions is not being met. There is a need for a system that can solve these issues.

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

[0648] In this invention, the server includes means for inputting user information, means for acquiring store information at regular time intervals, means for generating recipes using a generative AI model based on the user information and the store information, means for presenting the generated recipes to a user terminal, means for displaying to the user details of ingredients needed from the recipes and a sales area guide, means for identifying products that are close to their expiration date or are in excess of stock, regenerating recipes that prioritize the identified products, and presenting these to the user terminal, and means for identifying plus-one products based on the user's purchase history and preference information, and suggesting the identified products to the user. This makes it possible to reduce food waste and improve the consumer shopping experience.

[0649] "User information" refers to personal information provided by a user to the system, including family composition, food preferences, budget, cooking experience, health status, and the like.

[0650] "Store information" refers to data such as inventory information, prices, expiration dates, featured products, etc., related to a particular store.

[0651] "Generative AI model" refers to an artificial intelligence model used to automatically generate optimal recipes based on user and store information.

[0652] "Recipe" refers to information provided to a user that includes instructions and a list of ingredients needed to prepare a particular dish.

[0653] "User terminal" refers to a device used by a user to access the system and input or receive information, including smartphones, tablets, etc.

[0654] "Products with an approaching expiration date" refers to products whose best-before date or expiration date is approaching.

[0655] "Overstocked items" refers to items that are overstocked in a store.

[0656] "Plus one products" refer to complementary products such as beverages and snacks that are suggested for addition to the main shopping list based on the user's purchase history and preference information.

[0657] "Sales floor guide" refers to information indicating where in the store the food ingredients that the user is trying to purchase are located.

[0658] This invention is a system that reduces food waste and improves the consumer's shopping experience by generating optimal recipes based on user and store information and presenting them to the user. This system is composed of multiple components, including a user terminal, a server, and a database, and operates as follows:

[0659] System Configuration

[0660] This system consists of a user terminal, a server, and a database. The user terminal is a smartphone or tablet, and is the device through which the user inputs and receives information into the system. The server runs programs including the generative AI model and plays a central role in data analysis and recipe generation. The database stores user information and store information, and the server accesses it to obtain the necessary information.

[0661] Obtaining user information

[0662] A user logs into the "Smart Basket" app and enters information such as family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the user's device to the server. The server stores the received user information in a database and creates and updates the user profile.

[0663] Obtaining store information

[0664] The server calls the API at regular intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained information is analyzed by the server and stored in a database.

[0665] Recipe Generation

[0666] The server uses a generative AI model to generate optimal recipes based on user and store information. The recipe manager GPT creates recipes taking into account the user profile and store inventory. The generated recipe candidates are stored in a database.

[0667] Recipe presentation and product information

[0668] The user's device displays a notification of the recipe suggestion to the user. When the user confirms the notification and opens the app to check the suggested recipe, the user's device displays the recipe details (ingredients, cooking instructions) and information about where to buy the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the user's device.

[0669] Proposal for unsold products

[0670] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates a new recipe that prioritizes the use of the identified products and notifies the user's device.

[0671] Plus One Proposal

[0672] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information. It then generates a suggestion message and sends it to the user's device. The user can then review the suggested "plus one" items and choose whether to add them to their shopping list.

[0673] Specific examples

[0674] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[0675] 2. The device sends this information to the server, which updates the user profile.

[0676] 3. The server retrieves the store information and stores it in the database.

[0677] 4. The server calls the recipe GPT, generates a "Japanese food recipe", and saves it. An example prompt is as follows:

[0678] "Generate recipes using mackerel, Chinese cabbage, and tofu for a user who likes Japanese food but has an egg allergy."

[0679] 5. The device notifies user A of the recipe suggestion and displays details and sales area information.

[0680] 6. The server regenerates and suggests recipes using ingredients that are close to their expiration date.

[0681] 7. The device suggests additional items such as green tea and Japanese sweets to User A.

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

[0683] Step 1: Enter your user information

[0684] A user logs in to the "Smart Basket" app and enters information such as family composition, food preferences, budget, cooking experience, and health condition. The information entered includes the user's family composition (e.g., a family of three), food preferences (e.g., likes Japanese food), budget (e.g., 5,000 yen per week), cooking experience (e.g., intermediate), and health condition (e.g., egg allergy).

[0685] The terminal sends the input information to the server in JSON format. Here, input is the information the user enters into the terminal, and output is the JSON data sent to the server.

[0686] Step 2: Save user information

[0687] The server saves the received user information in the database. Specifically, it parses the JSON data received on the server side and inserts it into the "user_profiles" table.

[0688] Input: JSON data sent from the terminal

[0689] Output: Save data to database

[0690] Step 3: Get store information

[0691] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. Specifically, the server uses a Cron job to periodically send an HTTP GET request to the store API.

[0692] Input: API request via Cron job

[0693] Output: Obtain store information data

[0694] Step 4: Save your store information

[0695] The server analyzes the acquired store information and stores it in a database. For example, it stores inventory information in the "inventory" table.

[0696] Input: Acquired store information data

[0697] Output: Save data to database

[0698] Step 5: Generate the recipe

[0699] The server generates the optimal recipe using a generative AI model (e.g., GPT-3) based on user and store information. The prompt might be, "Generate a recipe using mackerel, Chinese cabbage, and tofu for a user who likes Japanese food but has an egg allergy."

[0700] Input: User information and store information

[0701] Output: Generated recipe data

[0702] Step 6: Save the recipe

[0703] The server saves the generated recipe information to a database. Specifically, it inserts the recipes returned by the generative AI model into the "recipes" table.

[0704] Input: Generated recipe data

[0705] Output: Save data to database

[0706] Step 7: Recipe Suggestion Notifications

[0707] The device displays a recipe suggestion notification to the user, for example, by sending a push notification using Firebase Cloud Messaging.

[0708] Input: Recipe suggestion data from the server

[0709] Output: Push notification to the user

[0710] Step 8: View Recipe Details

[0711] When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and where to buy those ingredients. For example, the information is displayed in HTML format on the recipe details screen within the app.

[0712] Input: Recipe suggestion notification that the user confirmed in the app

[0713] Output: Recipe details

[0714] Step 9: Generate a shopping list

[0715] When a user selects a recipe, a shopping list is automatically generated and displayed on the user's terminal, for example, a list of ingredients for the selected recipe.

[0716] Input: User's recipe selection

[0717] Output: Auto-generated shopping list

[0718] Step 10: Identifying products with approaching expiration dates and generating recipes

[0719] The server identifies products that are close to their expiration date or are in excess of stock from store information, and prioritizes regenerating recipes that use these products. For example, it uses an SQL query to extract products that are close to their expiration date from the "inventory" table.

[0720] Input: Store inventory information

[0721] Output: Recipe data based on products with an approaching expiration date

[0722] Step 11: Regenerated Recipe Suggestion

[0723] The device notifies the user of the regenerated recipe, for example by sending a push notification.

[0724] Input: Regenerated recipe data

[0725] Output: Push notification to the user

[0726] Step 12: Propose a Plus One Product

[0727] The server identifies plus-one products based on the user's purchase history and preference information, generates a recommendation message, and sends it to the user's device. For example, the server identifies recommended products using a machine learning model.

[0728] Input: User purchase history and preference information

[0729] Output: Plus one product suggestion message

[0730] Step 13: Check and add your Plus One items

[0731] The user checks the suggested plus-one items and selects whether to add them to the shopping list. The terminal updates the shopping list according to the user's selection.

[0732] Input: Plus One product suggestion message

[0733] Output: Updated shopping list

[0734] (Application example 1)

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

[0736] Conventional systems have difficulty proposing optimal recipes based on a user's individual preferences and household circumstances, and have been inadequate in proposing recipes that utilize products that are nearing their expiration date or that are overstocked. It has also been difficult to appropriately suggest "plus-one" products or promotional products, resulting in insufficient reduction of food waste and insufficient sales promotion. Furthermore, there is no in-store guidance to help users efficiently purchase the ingredients they need, which has led to inefficient shopping.

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

[0738] In this invention, the server includes a means for inputting user information, a means for acquiring store information, a means for generating a recipe based on the user information and the store information, a means for generating an optimal recipe using a generative AI model, a means for generating a prompt and acquiring a recipe, a means for presenting the generated recipe to the user, and a means for providing information on ingredients needed from the recipe. This allows for optimal recipe suggestions based on the user's preferences and health status. Furthermore, the server can suggest recipes using products with approaching expiration dates or overstocked items, as well as appropriate suggestions for additional products and advertised items, effectively reducing food waste and promoting sales. Furthermore, the server provides in-store guidance to help users efficiently purchase the ingredients they need, improving shopping efficiency.

[0739] "User information" is personal data such as the user's family structure, food preferences, budget, cooking experience, and health condition.

[0740] "Store information" refers to data about the store, such as store inventory, prices, expiration dates, and featured products.

[0741] The "recipe generation means" refers to a program or algorithm for creating an appropriate recipe based on user information and store information.

[0742] A "generative AI model" is a technology for generating text and information using large-scale language models and generative artificial intelligence.

[0743] A "prompt" is a question or instruction written in a specific format to be input into a generative AI model.

[0744] A "generated recipe" is a cooking procedure and ingredient list created by a generative AI model that takes into account user and store information.

[0745] The "user presentation means" refers to a device or software for displaying the generated recipe to the user.

[0746] The "ingredient guide means" is a system or method for informing the user of the location in the store of ingredients required for a recipe and a shopping list.

[0747] This invention is a system that generates optimal recipes based on user information and store information and presents them to consumers. The purpose of this system is to reduce food waste and promote sales. This system, "Smart Basket," consists of a user terminal, a server, and a database, and is specifically configured as follows:

[0748] System Configuration

[0749] User terminal

[0750] A user device refers to a device such as a smartphone or tablet. The user uses this device to access the application and enter information such as family composition, food preferences, budget, cooking experience, and health status. The entered user information is sent from the device to the server.

[0751] server

[0752] The server receives information sent from the user's device and stores it in a database. It also periodically calls an API to obtain store information such as store inventory, prices, expiration dates, and featured products. The server also calls the generative AI model and generates recipes.

[0753] Database

[0754] The database stores user and store information. The server accesses this database to obtain the necessary information and uses it to generate recipes.

[0755] Program processing

[0756] Obtaining user information

[0757] The user logs in to the app and enters the necessary information (family composition, food preferences, budget, cooking experience, health condition, etc.). The user's device sends the entered information to the server.

[0758] Obtaining store information

[0759] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained information is analyzed and stored in a database.

[0760] Generating recipe candidates

[0761] The server generates a recipe by calling a generative AI model based on the user and store information. This AI model generates the optimal recipe taking into account the user profile (e.g., "likes Japanese food") and the store's inventory (e.g., mackerel, Chinese cabbage, tofu). An example of this prompt is as follows:

[0762] User profile: {'family': 'Family of 4', 'food_pref': 'Japanese food', 'budget': '5000 yen', 'cooking_experience': 'Intermediate', 'health_status': 'None in particular'}

[0763] Store inventory: {'Mackerel': '10', 'Chinese cabbage': '15', 'Tofu': '20', 'Green onion': '25', 'Soy sauce': '30'}

[0764] Use this information to generate the best recipe possible.

[0765] Recipe presentation and product information

[0766] The user's device will display a notification of the suggested recipe to the user. When the user opens the app and checks the suggested recipe, the device will display the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list will be automatically generated and displayed on the device.

[0767] Proposal for unsold products

[0768] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize these items. Recipes based on this information are also suggested to the user on their device.

[0769] Plus One Proposal

[0770] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the "plus one" item suggestion to the user, who can then choose whether to add it to their shopping list.

[0771] Advertisement product proposals

[0772] When a food manufacturer provides advertising campaign information to the server, the server invokes the generative AI model to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[0773] This allows users to find the most suitable recipes, making shopping more efficient and eco-friendly. It also offers appropriate suggestions for plus-one products and promotional items, which is expected to have a positive effect on sales promotion.

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

[0775] Step 1:

[0776] A user logs in to the application using a smartphone device. The user enters user information such as family composition, food preferences, budget, cooking experience, and health condition. This user information set is entered into the device and sent as is to the server. The input data is packaged in JSON format or similar and sent to the server via a secure API.

[0777] Step 2:

[0778] The server analyzes the user information received via a secure API and stores it in a database. It analyzes the received data to generate a user profile and stores the profile information in a database, making the user information available for subsequent processing.

[0779] Step 3:

[0780] The server calls the API at specific time intervals to obtain store information such as store inventory, prices, expiration dates, and featured products. This obtains the latest store information. The obtained store information is then retrieved again through a secure API, and the server analyzes the data and saves it in a database. This saves the latest information on inventory, prices, expiration dates, etc.

[0781] Step 4:

[0782] The server generates a recipe by calling the generative AI model based on the user information and store information. It then generates a prompt for the generative AI model and sends a request to the AI ​​using that prompt. For example, it generates the following prompt:

[0783] User profile: {'family': 'Family of 4', 'food_pref': 'Japanese food', 'budget': '5000 yen', 'cooking_experience': 'Intermediate', 'health_status': 'None in particular'}

[0784] Store inventory: {'Mackerel': '10', 'Chinese cabbage': '15', 'Tofu': '20', 'Green onion': '25', 'Soy sauce': '30'}

[0785] Use this information to generate the best recipe possible.

[0786] The server analyzes the generated recipe and stores it in a database.

[0787] Step 5:

[0788] The user's device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients (location in the store) to the user. The input data is the recipe information selected by the user, and the output data is the specific cooking steps, shopping list, and in-store directions.

[0789] Step 6:

[0790] The server identifies products that are close to their expiration date or are in excess of stock from store information, and regenerates recipes that prioritize the use of these products. This generates recipes that can utilize products that are close to their expiration date or are in excess of stock, and sends them to the terminal. The user is also notified again.

[0791] Step 7:

[0792] The server identifies plus-one items such as beverages and confectionery based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the suggested plus-one items to the user and allows them to choose whether to add them to their shopping list. If the user chooses to add them, the information is sent to the server and the shopping list is updated.

[0793] Step 8:

[0794] When a food manufacturer provides advertising campaign information to the server, the server invokes the generative AI model to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipe and displays it to encourage them to purchase it. If the user adds the advertised product to their shopping list, that information is sent to the server and the shopping list is updated.

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

[0796] This invention is a system that reduces food waste and promotes sales by generating optimal recipes based on user information and store information, and then using an emotion engine to make suggestions based on the user's emotions. Specifically, this system is configured and operates as follows.

[0797] System Configuration

[0798] This system, "Smart Basket," consists of a user device, a server, a database, and an emotion engine. The user device is a smartphone or tablet, which communicates with the server to send and receive information. The server runs a program incorporating generative AI and an emotion engine to generate recipes and analyze user emotions. User information and store information is stored in the database, which the server accesses to obtain the necessary information.

[0799] Program processing

[0800] Obtaining user information

[0801] Users log in to the "Smart Basket" app and enter information such as family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to the server, which stores it in a database and creates a user profile.

[0802] Obtaining store information

[0803] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database.

[0804] Generating recipe candidates

[0805] The server generates a recipe by calling the recipe GPT based on the user and store information. The recipe GPT takes into account the user profile (e.g., likes Japanese food, has an egg allergy) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate the optimal recipe. The generated recipe candidates are stored in a database.

[0806] Emotion recognition and recipe adjustment

[0807] The device collects emotional data from the user's facial expressions and voice. The emotion engine analyzes this data and identifies the user's current emotion (e.g., joy, sadness, stress). The server adjusts the recipe based on the acquired emotional data and makes suggestions according to the user's emotions.

[0808] Recipe presentation and product information

[0809] The device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[0810] Proposal for unsold products

[0811] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize the use of the identified products. Recipes based on this information are also suggested to the user on the device.

[0812] Plus One Proposal

[0813] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history, preference information, and emotional data, and generates a suggestion message that it sends to the device. The device then displays the "plus one" item suggestions to the user, who can then choose whether to add them to their shopping list.

[0814] Advertisement product proposals

[0815] When a food manufacturer provides advertising campaign information to the server, the server calls the recipe GPT to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[0816] Specific examples

[0817] Example 1: Customer A's case

[0818] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[0819] 2. The device sends the input information to the server, which updates the user profile.

[0820] 3. The server retrieves the store information and stores it in the database.

[0821] 4. The server calls the recipe GPT to generate and save a "Japanese food recipe."

[0822] 5. The device collects user A's emotion data and sends it to the server.

[0823] 6. The emotion engine analyzes User A's emotions and determines, for example, that he is under high stress.

[0824] 7. Based on the emotional data obtained, the server adjusts and suggests recipes suitable for reducing stress.

[0825] 8. The device provides recipes, displays shopping lists and store directions.

[0826] 9. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[0827] 10. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[0828] Example 2: Advertising

[0829] 1. Food manufacturers provide information about new products to a server.

[0830] 2. The server calls the recipe GPT to generate a recipe containing the advertised product.

[0831] 3. The server saves the generated recipe in the database.

[0832] 4. The device collects user B's emotion data and sends it to the server.

[0833] 5. The emotion engine analyzes User B's emotions and determines that, for example, they are feeling a high level of joy.

[0834] 6. The server adjusts and proposes recipes for advertising products based on the obtained emotional data.

[0835] 7. The device notifies User B of the recipe that includes the advertised item. User B adds the suggested item to their shopping list.

[0836] The processing flow will be explained below.

[0837] Step 1:

[0838] The user logs in to the "Smart Basket" app.

[0839] Step 2:

[0840] The device prompts the user to enter information such as family composition, food preferences, budget, cooking experience, and health status.

[0841] Step 3:

[0842] The terminal transmits the input user information to the server.

[0843] Step 4:

[0844] The server stores the received user information in a database and updates the user profile.

[0845] Step 5:

[0846] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc.

[0847] Step 6:

[0848] The server analyzes the store information it has acquired and processes it as necessary (e.g., standardizing date formats, cleaning data).

[0849] Step 7:

[0850] The server stores the analyzed store information in a database.

[0851] Step 8:

[0852] The server calls the recipe manager GPT based on the user information and store information to generate a recipe.

[0853] Step 9:

[0854] The recipe GPT takes into account the user profile (e.g., likes Japanese food, allergy to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate optimal recipe candidates.

[0855] Step 10:

[0856] The server stores the generated recipes in a database for each user.

[0857] Step 11:

[0858] The device collects emotional data from the user's facial expressions, voice, etc.

[0859] Step 12:

[0860] The device transmits the collected emotion data to a server.

[0861] Step 13:

[0862] The emotion engine analyzes the user's emotion data to identify their current emotional state (e.g., joy, sadness, stress).

[0863] Step 14:

[0864] The server adjusts the recipe based on the obtained emotional data and selects the optimal recipe according to the user's emotions.

[0865] Step 15:

[0866] The device displays a notification of the tailored recipe suggestions to the user.

[0867] Step 16:

[0868] The user opens the app and sees the suggested recipes.

[0869] Step 17:

[0870] The device displays the recipe details (ingredients, instructions) and the location of the ingredients (location within the store) to the user.

[0871] Step 18:

[0872] Users select their favorite recipes and add them to their shopping list.

[0873] Step 19:

[0874] The server identifies products that are close to their expiration date or that are in excess of stock from store information.

[0875] Step 20:

[0876] The server calls the recipe manager GPT again to generate a recipe that prioritizes the use of the identified products.

[0877] Step 21:

[0878] Recipe GPT generates recipes using these products.

[0879] Step 22:

[0880] The server updates the recipe database to suggest the generated recipes to the user.

[0881] Step 23:

[0882] The device notifies the user of suggestions for additional products (e.g., drinks or sweets).

[0883] Step 24:

[0884] The server obtains the information about the advertised products and calls the recipe GPT to generate a recipe that includes the advertised products.

[0885] Step 25:

[0886] Recipe GPT generates recipes that include the advertised products.

[0887] Step 26:

[0888] The server stores the advertised recipes in a database and suggests them to users who meet certain conditions.

[0889] Step 27:

[0890] The terminal notifies the user of the advertised recipe and encourages them to make a purchase.

[0891] Example 2

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

[0893] In today's consumer society, there is a need to efficiently reduce food waste and increase consumer purchasing power, but to achieve this, it is necessary to make proposals that respond to the diverse needs and emotions of consumers.In addition, it is also important to reflect store inventory information in real time, appropriately utilize products that are approaching their expiration date, and efficiently promote advertised products.

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

[0895] In this invention, the server includes means for inputting user information, means for acquiring store information, means for generating recipes based on the user information and the store information, means for presenting the generated recipes to the user, means for suggesting ingredients needed from the recipes, means for collecting emotion data, means for analyzing the collected emotion data and adjusting the recipes based on the user's emotion, and means for suggesting plus-one products based on the user's purchase history and preference information. This makes it possible to provide appropriate recipe suggestions and purchasing processes according to the needs and emotions of each user, thereby effectively reducing food waste and promoting sales.

[0896] "User information" is personal data of the user, including family composition, food preferences, budget, cooking experience, health condition, and the like.

[0897] "Store information" is data obtained from the store, and includes inventory information, prices, expiration dates, featured products, and the like.

[0898] A "recipe" is a list of instructions and ingredients for preparing a particular dish or meal.

[0899] "Emotion data" is data that indicates the psychological state of the user, obtained from facial expressions, voice, etc.

[0900] "Plus one product" refers to an additional product such as a drink or snack that is suggested in addition to the product that the user is primarily intending to purchase.

[0901] "Advertised products" are products that are the subject of a specific campaign and are proposed by companies or manufacturers for promotional purposes.

[0902] An "emotion engine" refers to a program or function that analyzes emotional data collected from a user and identifies the user's psychological state.

[0903] A "generative AI model" refers to an artificial intelligence algorithm that generates appropriate output based on input data.

[0904] An "API" is an interface that allows applications to connect with other services and databases.

[0905] "Database" refers to a structured collection of data for efficiently storing and managing data used within a system.

[0906] A "terminal" is a device that a user can directly operate, and includes a smartphone, tablet, etc.

[0907] A "server" refers to a combination of a computer and software for managing the entire system and processing data.

[0908] This invention is a recipe suggestion system for reducing food waste and promoting sales, and is composed of a user terminal, a server, a database, and an emotion engine. This system automatically collects user information, acquires store information, and generates optimal recipes based on this information and suggests them to the user.

[0909] Registering user information

[0910] Users log in to the "Smart Basket" app from their smartphones, tablets, or other devices and enter information such as their family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the device to the server, which then stores the received information in a database and creates a user profile.

[0911] Obtaining store information

[0912] The server uses the API at specific intervals (e.g., every hour) to retrieve store inventory information, prices, expiration dates, featured products, etc. The retrieved information is analyzed by the server and stored in a database. This data is later used to generate recipes.

[0913] Generating recipe candidates

[0914] The server calls the generative AI model (GPT for recipes) based on the user profile and store information to generate the optimal recipe. For example, if a user prefers Japanese food but is allergic to eggs, the generative AI model will generate recipes using mackerel, Chinese cabbage, and tofu based on the store's inventory. The generated recipe candidates are saved in a database.

[0915] Emotion recognition and recipe adjustment

[0916] The device collects emotional data from the user's facial expressions and voice and sends it to the server. The server then uses an emotion engine to analyze the emotional data and identify the user's current emotional state. For example, if the user is feeling stressed, the server adjusts the recipes it has generated and suggests recipes that are suitable for reducing stress.

[0917] Recipe presentation and product information

[0918] The device displays a notification of the recipe suggestion to the user. When the user confirms the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[0919] Proposal for unsold products

[0920] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and regenerates recipes that prioritize these items. This new recipe is also suggested to the user on their device.

[0921] Plus one product proposal

[0922] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history, preference information, and emotional data. The generated suggestion message is sent from the server to the terminal, and the "plus one" item suggestion is displayed to the user. The user can choose whether to add it to their shopping list.

[0923] Advertisement product proposals

[0924] When a food manufacturer provides information about a new product to the server, the server invokes a generative AI model (GPT for recipes) to generate a recipe that includes the advertised product. This new recipe is then provided to users who meet certain conditions. The device notifies the user of the advertised recipe, allowing them to consider purchasing it.

[0925] Specific examples

[0926] Example 1: Customer A's case

[0927] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[0928] 2. The device sends the input information to the server, which updates the user profile.

[0929] 3. The server retrieves the store information and stores it in the database.

[0930] 4. The server calls the generative AI model (GPT for recipes) to generate and save a "Japanese food recipe."

[0931] 5. The device collects user A's emotion data and sends it to the server.

[0932] 6. The emotion engine analyzes User A's emotions and determines, for example, that he is under high stress.

[0933] 7. Based on the emotional data obtained, the server adjusts and suggests recipes suitable for reducing stress.

[0934] 8. The device provides recipes, displays shopping lists and store directions.

[0935] 9. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[0936] 10. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[0937] Prompt Sentence Examples

[0938] 1. Basic recipe generation:

[0939] "Generate new recipes taking into account the user profile (e.g., I like Japanese food, I'm allergic to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu)."

[0940] 2. Adjust recipes according to emotions:

[0941] "Generate relaxing Japanese food recipes for users who are under a lot of stress."

[0942] 3. Disposal of unsold items:

[0943] "Please generate recipes using products that are close to their expiration date (e.g., tofu, mackerel)."

[0944] 4. Recipes containing the advertised product:

[0945] "Generate recipes that include new products from food manufacturers (e.g., specific seasonings)."

[0946] This system provides recipe suggestions and purchasing processes that respond to users' diverse needs and emotions, making it possible to effectively reduce food waste and promote sales.

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

[0948] Step 1: Register user information

[0949] Users log in to the app from a device such as a smartphone or tablet and enter information such as their family composition, food preferences, budget, cooking experience, and health condition. The entered information is sent from the device to the server. The server stores the received information in a database and creates a user profile. This enables the system to suggest recipes tailored to each individual user. The input is a form of user information, and the output is the user profile in the database.

[0950] Step 2: Get store information

[0951] The server uses the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database. This data is later used for recipe generation and inventory management. The input is the API response, and the output is the store information in the database.

[0952] Step 3: Generate recipe candidates

[0953] The server calls the generative AI model (GPT for recipes) based on the user profile and store information to generate the optimal recipe. For example, if the user prefers Japanese food and is allergic to eggs, the generative AI model will generate a recipe using mackerel, Chinese cabbage, and tofu based on the store's inventory. The generated recipe candidates are stored in a database. The input is user and store data, and the output is the generated recipe.

[0954] Step 4: Emotion recognition and recipe adjustment

[0955] The device collects emotional data from the user's facial expressions and voice and sends it to the server. The server then uses an emotion engine to analyze the emotional data and identify the user's current emotional state. For example, if the user is feeling stressed, the server adjusts the recipes it has generated and suggests recipes that are suitable for reducing stress. The input is facial expressions and voice, and the output is the user's emotional state.

[0956] Step 5: Present the recipe and introduce the product

[0957] The device displays a notification of a recipe suggestion to the user. When the user confirms the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the device. The input is the user's selection, and the output is the display content and the shopping list.

[0958] Step 6: Propose unsold items

[0959] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and regenerates recipes that prioritize these items. These new recipes are also suggested to users on their devices. This allows for products with low demand to be sold. The input is stock information, and the output is the regenerated recipe.

[0960] Step 7: Propose a Plus One Product

[0961] The server identifies plus-one products such as beverages and confectionery based on the user's purchase history, preference information, and emotional data. The generated suggestion message is sent from the server to the terminal, and the plus-one product suggestion is displayed to the user. The user can choose whether to add this to their shopping list. The input is the purchase history and emotional data, and the output is the suggestion message.

[0962] Step 8: Propose advertising products

[0963] When a food manufacturer provides information about new products and advertising campaigns to the server, the server calls a generative AI model (GPT for recipes) to generate recipes that include the advertised products based on that information. These new recipes are then provided to users who meet certain conditions. The device notifies the user of the advertised recipe, allowing them to consider purchasing it. The input is new product information, and the output is a recipe that includes the advertisement.

[0964] (Application example 2)

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

[0966] Conventional recipe suggestion systems suggest recipes based on a user's food preferences and health status, but do not take into account emotions or real-time store information, which limits their effectiveness in increasing user satisfaction and reducing food waste. This invention solves the problem of more effectively reducing food waste and promoting sales by generating and suggesting optimal recipes based on the user's emotions and real-time store information.

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

[0968] In this invention, the server includes means for inputting user information, means for acquiring store information, means for generating a recipe based on the user information and the store information, means for presenting the generated recipe to the user, means for indicating ingredients needed from the recipe, means for recognizing the user's emotions, and means for adjusting the recipe in accordance with the emotions. This makes it possible to propose optimal recipes taking the user's emotions into consideration, thereby improving user satisfaction, reducing food waste, and promoting store sales.

[0969] "User information" refers to information entered by the user, such as family composition, food preferences, budget, cooking experience, and health condition.

[0970] "Store information" refers to information acquired in real time, such as store inventory, prices, expiration dates, and featured products.

[0971] A "recipe" is a list of cooking procedures and necessary ingredients generated based on user information and store information.

[0972] "User's emotion" refers to an emotional state recognized from the user's facial expression, voice, etc., and includes, for example, joy, sadness, stress, etc.

[0973] An "emotion engine" is software or hardware for analyzing a user's emotion data and identifying the user's current emotion.

[0974] A "smartphone" is a portable communication device that a user uses to run applications.

[0975] "Generative AI" is an artificial intelligence model that generates optimal recipes based on user and store information.

[0976] "Navigation" is a function that provides directions for users to obtain the ingredients they need within the store.

[0977] The present invention is a system that generates optimal recipes based on "user information" and "store information," and then uses an "emotion engine" to make suggestions based on the user's emotions. The system is composed of a user terminal, a server, and a database, and is operated using a smartphone application. Specific embodiments are described below.

[0978] System Configuration

[0979] User terminal

[0980] The user device is primarily a smartphone. Once the user installs the app and logs in, they can input and save their "user information" such as their family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to a server and stored in a database.

[0981] server

[0982] The server is the main component that runs the program, which includes the following functions:

[0983] 1. Saving user information: The server saves the user information sent from the user terminal in a database and creates a user profile.

[0984] 2. Obtaining store information: The server periodically obtains "store information" such as store inventory, prices, expiration dates, and featured products through the API and stores it in a database.

[0985] 3. Recipe generation: The server generates the optimal recipe using a "generative AI model" based on user and store information. For example, OpenAI's GPT-4 is used for generation.

[0986] 4. Emotion analysis: The server analyzes the emotion data sent from the user's device using an "emotion engine" to identify the user's current emotion.

[0987] 5. Recipe adjustment: Based on the emotional data, the optimal recipe is readjusted and suggested to the user.

[0988] Database

[0989] The database stores and manages user information, store information, generated recipes, and the like.

[0990] Operation procedure and data processing flow

[0991] 1. Enter and save user information

[0992] The user logs in to the smartphone application and enters the required information.

[0993] The entered information is sent from the terminal to the server and stored in a database.

[0994] 2. Obtaining store information

[0995] The server periodically retrieves store inventory and price information from the API.

[0996] Save the acquired store information in the database.

[0997] 3. Recipe generation and suggestions

[0998] The server calls a generative AI model based on user information and store information and generates a recipe.

[0999] The generated recipes are stored in a database and suggested to users.

[1000] 4. Sentiment analysis and recipe adjustment

[1001] The emotion engine analyzes emotions based on facial expressions and voice data sent from the user's device.

[1002] Based on the obtained emotional data, the server readjusts the recipe and presents it to the user.

[1003] Specific examples

[1004] Example 1: Customer A's case

[1005] 1. User A logs in to the smartphone app and enters their food preferences and health status.

[1006] 2. The server retrieves the store's inventory information and stores it in a database.

[1007] 3. The server uses the generative AI model to generate a "Japanese food recipe."

[1008] 4. Analyze the user's emotional data (e.g., stress) and adjust the recipe accordingly.

[1009] 5. The smartphone app suggests the best recipe for User A and provides guidance on where to buy the necessary ingredients.

[1010] Prompt Sentence Examples

[1011] User Profile:

[1012] I like Japanese food

[1013] Egg allergy

[1014] I feel stressed easily recently

[1015] Store inventory information:

[1016] The mackerel is fresh

[1017] Abundant Chinese cabbage

[1018] There is little tofu left

[1019] Generate the recipe:

[1020] Contains ingredients that help reduce stress

[1021] Easy to cook

[1022] It is Japanese food

[1023] Based on this prompt, the generative AI model generates an appropriate recipe and suggests it to the user. This embodiment makes it possible to suggest optimal recipes that take the user's emotions into consideration, thereby improving user satisfaction, reducing food waste, and promoting store sales.

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

[1025] Step 1:

[1026] A user logs in to the smartphone app and enters user information such as family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the device to the server, which then stores it in a database. This creates a user profile.

[1027] Input: User information (family composition, food preferences, budget, cooking experience, health condition)

[1028] Output: User profile stored in the database

[1029] Specific operation: Enter user information into the input form on the smartphone app screen and press the send button. The input information is sent to the server and saved in the database.

[1030] Step 2:

[1031] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained store information is analyzed by the server and stored in a database.

[1032] Input: Store information API

[1033] Output: Store information saved in the database

[1034] Specific operation: A program on the server periodically calls the store information API, analyzes the acquired data, and stores it in a database.

[1035] Step 3:

[1036] The server calls the generative AI model based on user and store information to generate optimal recipes. The generated recipes are stored in a database and presented to the user as needed.

[1037] Input: User profile, store information

[1038] Output: Generated recipe (stored in database)

[1039] Specific operation: The server inputs user information and store information into the generative AI model to generate prompt text. The generative AI model then generates the optimal recipe and stores the results in a database.

[1040] Step 4:

[1041] The user device uses a camera and microphone to collect facial and voice data from the user and transmits it to the server, which then uses an emotion engine to analyze this data and determine the user's current emotion.

[1042] Input: User's facial expression data, voice data

[1043] Output: Parsed emotion data

[1044] Specific operation: The user takes a facial expression in front of the smartphone camera or speaks into the microphone. This data is sent to the server and analyzed by the emotion engine.

[1045] Step 5:

[1046] The server readjusts the optimal recipe based on the analyzed emotional data. The readjusted recipe is sent to the user's device and presented to the user. This allows the server to suggest recipes that match the user's current emotions.

[1047] Input: emotion data, existing recipes

[1048] Output: Reworked recipe

[1049] Specific operation: The server analyzes the emotion data, regenerates or adjusts the recipe, and sends the results to the user's smartphone, where the recipe is displayed.

[1050] Step 6:

[1051] The user device automatically generates a shopping list based on the optimal recipe, and also provides navigation to the store and guides the user to the location of the ingredients they need.

[1052] Input: Reworked recipe

[1053] Output: Purchase list, store information

[1054] Specific operation: When the user views the recipe display screen of the app, a shopping list is automatically generated. The app displays the route to the sales floor and begins navigation.

[1055] Step 7:

[1056] The server identifies products that are nearing their expiration date or are in excess of stock from the store's inventory information, and generates recipes using these products. The generated recipes are sent to the user's terminal and presented as additional suggestions.

[1057] Input: Store information

[1058] Output: Inventory adjustment recipe

[1059] Specific operation: The server analyzes store information and sends prompt text to the generation AI model, prioritizing products with an approaching expiration date or overstocked items. The generated recipe is then presented to the user.

[1060] Step 8:

[1061] The server suggests additional products, such as beverages and snacks, based on the user's purchase history, preference information, and emotional data. A suggestion message is sent to the user's terminal, and the user can choose whether to add the product to their shopping list.

[1062] Input: purchase history, preference information, emotional data

[1063] Output: Additional product suggestions

[1064] Specific operation: The server analyzes purchase history and preference information, generates a list of additional products based on emotional data, and sends the list to the user's device to suggest additional purchases.

[1065] Prompt Sentence Examples

[1066] Here is an example prompt:

[1067] User Profile:

[1068] I like Japanese food

[1069] Egg allergy

[1070] I feel stressed easily recently

[1071] Store inventory information:

[1072] The mackerel is fresh

[1073] Abundant Chinese cabbage

[1074] There is little tofu left

[1075] Generate the recipe:

[1076] Contains ingredients that help reduce stress

[1077] Easy to cook

[1078] It is Japanese food

[1079] This allows for the generation of optimal recipes that take into account the user's emotions and store inventory information, reducing food waste and improving user satisfaction.

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

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

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

[1083] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1096] The present invention is a system that reduces food waste and promotes sales by generating optimal recipes based on user information and store information and presenting them to consumers. Specifically, this system is configured and operates as follows.

[1097] System Configuration

[1098] This system, "Smart Basket," consists of a user device, a server, and a database. The user device is a smartphone or tablet, which communicates with the server to send and receive information. The server runs a program incorporating generative AI to generate recipes and analyze data. User information and store information is stored in the database, which the server accesses to retrieve the necessary information.

[1099] Program processing

[1100] Obtaining user information

[1101] Users log in to the "Smart Basket" app and enter information such as family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to the server, which stores it in a database and creates a user profile.

[1102] Obtaining store information

[1103] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database.

[1104] Generating recipe candidates

[1105] The server generates a recipe by calling the recipe GPT based on the user and store information. The recipe GPT takes into account the user profile (e.g., likes Japanese food, has an egg allergy) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate the optimal recipe. The generated recipe candidates are stored in a database.

[1106] Recipe presentation and product information

[1107] The device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[1108] Proposal for unsold products

[1109] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize the use of the identified products. Recipes based on this information are also suggested to the user on the device.

[1110] Plus One Proposal

[1111] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the "plus one" item suggestion to the user, who can then choose whether to add it to their shopping list.

[1112] Advertisement product proposals

[1113] When a food manufacturer provides advertising campaign information to the server, the server calls the recipe GPT to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[1114] Specific examples

[1115] Example 1: Customer A's case

[1116] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[1117] 2. The device sends the input information to the server, which updates the user profile.

[1118] 3. The server retrieves the store information and stores it in the database.

[1119] 4. The server calls the recipe GPT to generate and save a "Japanese food recipe."

[1120] 5. The device provides the recipe to user A and displays a shopping list and store information.

[1121] 6. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[1122] 7. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[1123] Example 2: Advertising

[1124] 1. Food manufacturers provide information about new products to a server.

[1125] 2. The server calls the recipe GPT to generate a recipe containing the advertised product.

[1126] 3. The server saves the generated recipe in the database.

[1127] 4. The device notifies User B of the recipe that includes the advertised product. User B adds the suggested product to their shopping list.

[1128] The processing flow will be explained below.

[1129] Step 1:

[1130] The user logs in to the "Smart Basket" app.

[1131] Step 2:

[1132] The device prompts the user to enter information such as family composition, food preferences, budget, cooking experience, and health status.

[1133] Step 3:

[1134] The terminal transmits the input user information to the server.

[1135] Step 4:

[1136] The server stores the received user information in a database and updates the user profile.

[1137] Step 5:

[1138] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc.

[1139] Step 6:

[1140] The server analyzes the store information it has acquired and processes it as necessary (e.g., standardizing date formats, cleaning data).

[1141] Step 7:

[1142] The server stores the analyzed store information in a database.

[1143] Step 8:

[1144] The server calls the recipe manager GPT based on the user information and store information to generate a recipe.

[1145] Step 9:

[1146] The recipe manager, GPT, takes into account the customer profile (e.g., likes Japanese food, allergy to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate optimal recipe candidates.

[1147] Step 10:

[1148] The server stores the generated recipes in a database for each user.

[1149] Step 11:

[1150] The terminal displays a notification of the recipe suggestion to the user.

[1151] Step 12:

[1152] The user opens the app and sees the suggested recipes.

[1153] Step 13:

[1154] The device displays the recipe details (ingredients, instructions) and the location of the ingredients (location within the store) to the user.

[1155] Step 14:

[1156] Users select their favorite recipes and add them to their shopping list.

[1157] Step 15:

[1158] The server identifies products that are nearing expiration dates or are overstocked.

[1159] Step 16:

[1160] The server calls the recipe manager GPT again to generate a recipe that prioritizes the use of the identified products.

[1161] Step 17:

[1162] Recipe GPT generates recipes using these products.

[1163] Step 18:

[1164] The server updates the recipe database to suggest the generated recipes to the user.

[1165] Step 19:

[1166] The device notifies the user of suggestions for additional products (e.g., drinks or sweets).

[1167] Step 20:

[1168] The server obtains the information about the advertised products and calls the recipe GPT to generate a recipe that includes the advertised products.

[1169] Step 21:

[1170] Recipe GPT generates recipes that include the advertised products.

[1171] Step 22:

[1172] The server stores the advertised recipes in a database and suggests them to users who meet certain conditions.

[1173] Step 23:

[1174] The terminal notifies the user of the advertised recipe and encourages them to make a purchase.

[1175] Example 1

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

[1177] In today's food market, food waste due to expired or unsold products is a major problem. In addition, inventory management in stores is becoming increasingly complex, and there is a lack of information available to help consumers purchase ingredients efficiently. Furthermore, the need for recipe suggestions tailored to consumers' preferences and health conditions is not being met. There is a need for a system that can solve these issues.

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

[1179] In this invention, the server includes means for inputting user information, means for acquiring store information at regular intervals, means for generating recipes using a generative AI model based on the user information and the store information, means for presenting the generated recipes to a user terminal, means for displaying to the user details of ingredients needed from the recipes and a sales area guide, means for identifying products that are close to their expiration date or are in excess of stock, regenerating recipes that prioritize the identified products, and presenting the recipes to the user terminal, and means for identifying plus-one products based on the user's purchase history and preference information, and suggesting the identified products to the user. This makes it possible to reduce food waste and improve the consumer shopping experience.

[1180] "User information" refers to personal information provided by a user to the system, including family composition, food preferences, budget, cooking experience, health status, and the like.

[1181] "Store information" refers to data such as inventory information, prices, expiration dates, featured products, etc., related to a particular store.

[1182] "Generative AI model" refers to an artificial intelligence model used to automatically generate optimal recipes based on user and store information.

[1183] "Recipe" refers to information provided to a user that includes instructions and a list of ingredients needed to prepare a particular dish.

[1184] "User terminal" refers to a device used by a user to access the system and input or receive information, including smartphones, tablets, etc.

[1185] "Products with an approaching expiration date" refers to products whose best-before date or expiration date is approaching.

[1186] "Overstocked items" refers to items that are overstocked in a store.

[1187] "Plus one products" refer to complementary products such as beverages and snacks that are suggested for addition to the main shopping list based on the user's purchase history and preference information.

[1188] "Sales floor guide" refers to information indicating where in the store the food ingredients that the user is trying to purchase are located.

[1189] This invention is a system that reduces food waste and improves the consumer's shopping experience by generating optimal recipes based on user and store information and presenting them to the user. This system is composed of multiple components, including a user terminal, a server, and a database, and operates as follows:

[1190] System Configuration

[1191] This system consists of a user terminal, a server, and a database. The user terminal is a smartphone or tablet, and is the device through which the user inputs and receives information into the system. The server runs programs including the generative AI model and plays a central role in data analysis and recipe generation. The database stores user information and store information, and the server accesses it to obtain the necessary information.

[1192] Obtaining user information

[1193] A user logs into the "Smart Basket" app and enters information such as family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the user's device to the server. The server stores the received user information in a database and creates and updates the user profile.

[1194] Obtaining store information

[1195] The server calls the API at regular intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained information is analyzed by the server and stored in a database.

[1196] Recipe Generation

[1197] The server uses a generative AI model to generate optimal recipes based on user and store information. The recipe manager GPT creates recipes taking into account the user profile and store inventory. The generated recipe candidates are stored in a database.

[1198] Recipe presentation and product information

[1199] The user's device displays a notification of the recipe suggestion to the user. When the user confirms the notification and opens the app to check the suggested recipe, the user's device displays the recipe details (ingredients, cooking instructions) and information about where to buy the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the user's device.

[1200] Proposal for unsold products

[1201] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates a new recipe that prioritizes the use of the identified products and notifies the user's device.

[1202] Plus One Proposal

[1203] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information. It then generates a suggestion message and sends it to the user's device. The user can then review the suggested "plus one" items and choose whether to add them to their shopping list.

[1204] Specific examples

[1205] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[1206] 2. The device sends this information to the server, which updates the user profile.

[1207] 3. The server retrieves the store information and stores it in the database.

[1208] 4. The server calls the recipe GPT, generates a "Japanese food recipe", and saves it. An example prompt is as follows:

[1209] "Generate recipes using mackerel, Chinese cabbage, and tofu for a user who likes Japanese food but has an egg allergy."

[1210] 5. The device notifies user A of the recipe suggestion and displays details and sales area information.

[1211] 6. The server regenerates and suggests recipes using ingredients that are close to their expiration date.

[1212] 7. The device suggests additional items such as green tea and Japanese sweets to User A.

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

[1214] Step 1: Enter your user information

[1215] A user logs in to the "Smart Basket" app and enters information such as family composition, food preferences, budget, cooking experience, and health condition. The information entered includes the user's family composition (e.g., a family of three), food preferences (e.g., likes Japanese food), budget (e.g., 5,000 yen per week), cooking experience (e.g., intermediate), and health condition (e.g., egg allergy).

[1216] The terminal sends the input information to the server in JSON format. Here, input is the information the user enters into the terminal, and output is the JSON data sent to the server.

[1217] Step 2: Save user information

[1218] The server saves the received user information in the database. Specifically, it parses the JSON data received on the server side and inserts it into the "user_profiles" table.

[1219] Input: JSON data sent from the terminal

[1220] Output: Save data to database

[1221] Step 3: Get store information

[1222] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. Specifically, the server uses a Cron job to periodically send an HTTP GET request to the store API.

[1223] Input: API request via Cron job

[1224] Output: Obtain store information data

[1225] Step 4: Save your store information

[1226] The server analyzes the acquired store information and stores it in a database. For example, it stores inventory information in the "inventory" table.

[1227] Input: Acquired store information data

[1228] Output: Save data to database

[1229] Step 5: Generate the recipe

[1230] The server generates the optimal recipe using a generative AI model (e.g., GPT-3) based on user and store information. The prompt might be, "Generate a recipe using mackerel, Chinese cabbage, and tofu for a user who likes Japanese food but has an egg allergy."

[1231] Input: User information and store information

[1232] Output: Generated recipe data

[1233] Step 6: Save the recipe

[1234] The server saves the generated recipe information to a database. Specifically, it inserts the recipes returned by the generative AI model into the "recipes" table.

[1235] Input: Generated recipe data

[1236] Output: Save data to database

[1237] Step 7: Recipe Suggestion Notifications

[1238] The device displays a recipe suggestion notification to the user, for example, by sending a push notification using Firebase Cloud Messaging.

[1239] Input: Recipe suggestion data from the server

[1240] Output: Push notification to the user

[1241] Step 8: View Recipe Details

[1242] When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and where to buy those ingredients. For example, the information is displayed in HTML format on the recipe details screen within the app.

[1243] Input: Recipe suggestion notification that the user confirmed in the app

[1244] Output: Recipe details

[1245] Step 9: Generate a shopping list

[1246] When a user selects a recipe, a shopping list is automatically generated and displayed on the user's terminal, for example, a list of ingredients for the selected recipe.

[1247] Input: User's recipe selection

[1248] Output: Auto-generated shopping list

[1249] Step 10: Identifying products with approaching expiration dates and generating recipes

[1250] The server identifies products that are close to their expiration date or are in excess of stock from store information, and prioritizes regenerating recipes that use these products. For example, it uses an SQL query to extract products that are close to their expiration date from the "inventory" table.

[1251] Input: Store inventory information

[1252] Output: Recipe data based on products with an approaching expiration date

[1253] Step 11: Regenerated Recipe Suggestion

[1254] The device notifies the user of the regenerated recipe, for example by sending a push notification.

[1255] Input: Regenerated recipe data

[1256] Output: Push notification to the user

[1257] Step 12: Propose a Plus One Product

[1258] The server identifies plus-one products based on the user's purchase history and preference information, generates a recommendation message, and sends it to the user's device. For example, the server identifies recommended products using a machine learning model.

[1259] Input: User purchase history and preference information

[1260] Output: Plus one product suggestion message

[1261] Step 13: Check and add your Plus One items

[1262] The user checks the suggested plus-one items and selects whether to add them to the shopping list. The terminal updates the shopping list according to the user's selection.

[1263] Input: Plus One product suggestion message

[1264] Output: Updated shopping list

[1265] (Application example 1)

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

[1267] Conventional systems have difficulty proposing optimal recipes based on a user's individual preferences and household circumstances, and have been inadequate in proposing recipes that utilize products that are nearing their expiration date or that are overstocked. It has also been difficult to appropriately suggest "plus-one" products or promotional products, resulting in insufficient reduction of food waste and insufficient sales promotion. Furthermore, there is no in-store guidance to help users efficiently purchase the ingredients they need, which has led to inefficient shopping.

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

[1269] In this invention, the server includes a means for inputting user information, a means for acquiring store information, a means for generating a recipe based on the user information and the store information, a means for generating an optimal recipe using a generative AI model, a means for generating a prompt and acquiring a recipe, a means for presenting the generated recipe to the user, and a means for providing information on ingredients needed from the recipe. This allows for optimal recipe suggestions based on the user's preferences and health status. Furthermore, the server can suggest recipes using products with approaching expiration dates or overstocked items, as well as appropriate suggestions for additional products and advertised items, effectively reducing food waste and promoting sales. Furthermore, the server provides in-store guidance to help users efficiently purchase the ingredients they need, improving shopping efficiency.

[1270] "User information" is personal data such as the user's family structure, food preferences, budget, cooking experience, and health condition.

[1271] "Store information" refers to data about the store, such as store inventory, prices, expiration dates, and featured products.

[1272] The "recipe generation means" refers to a program or algorithm for creating an appropriate recipe based on user information and store information.

[1273] A "generative AI model" is a technology for generating text and information using large-scale language models and generative artificial intelligence.

[1274] A "prompt" is a question or instruction written in a specific format to be input into a generative AI model.

[1275] A "generated recipe" is a cooking procedure and ingredient list created by a generative AI model that takes into account user and store information.

[1276] The "user presentation means" refers to a device or software for displaying the generated recipe to the user.

[1277] The "ingredient guide means" is a system or method for informing the user of the location in the store of ingredients required for a recipe and a shopping list.

[1278] This invention is a system that generates optimal recipes based on user information and store information and presents them to consumers. The purpose of this system is to reduce food waste and promote sales. This system, "Smart Basket," consists of a user terminal, a server, and a database, and is specifically configured as follows:

[1279] System Configuration

[1280] User terminal

[1281] A user device refers to a device such as a smartphone or tablet. The user uses this device to access the application and enter information such as family composition, food preferences, budget, cooking experience, and health status. The entered user information is sent from the device to the server.

[1282] server

[1283] The server receives information sent from the user's device and stores it in a database. It also periodically calls an API to obtain store information such as store inventory, prices, expiration dates, and featured products. The server also calls the generative AI model and generates recipes.

[1284] Database

[1285] The database stores user and store information. The server accesses this database to obtain the necessary information and uses it to generate recipes.

[1286] Program processing

[1287] Obtaining user information

[1288] The user logs in to the app and enters the necessary information (family composition, food preferences, budget, cooking experience, health condition, etc.). The user's device sends the entered information to the server.

[1289] Obtaining store information

[1290] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained information is analyzed and stored in a database.

[1291] Generating recipe candidates

[1292] The server generates a recipe by calling a generative AI model based on the user and store information. This AI model generates the optimal recipe taking into account the user profile (e.g., "likes Japanese food") and the store's inventory (e.g., mackerel, Chinese cabbage, tofu). An example of this prompt is as follows:

[1293] User profile: {'family': 'Family of 4', 'food_pref': 'Japanese food', 'budget': '5000 yen', 'cooking_experience': 'Intermediate', 'health_status': 'None in particular'}

[1294] Store inventory: {'Mackerel': '10', 'Chinese cabbage': '15', 'Tofu': '20', 'Green onion': '25', 'Soy sauce': '30'}

[1295] Use this information to generate the best recipe possible.

[1296] Recipe presentation and product information

[1297] The user's device will display a notification of the suggested recipe to the user. When the user opens the app and checks the suggested recipe, the device will display the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list will be automatically generated and displayed on the device.

[1298] Proposal for unsold products

[1299] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize these items. Recipes based on this information are also suggested to the user on their device.

[1300] Plus One Proposal

[1301] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the "plus one" item suggestion to the user, who can then choose whether to add it to their shopping list.

[1302] Advertisement product proposals

[1303] When a food manufacturer provides advertising campaign information to the server, the server invokes the generative AI model to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[1304] This allows users to find the most suitable recipes, making shopping more efficient and eco-friendly. It also offers appropriate suggestions for plus-one products and promotional items, which is expected to have a positive effect on sales promotion.

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

[1306] Step 1:

[1307] A user logs in to the application using a smartphone device. The user enters user information such as family composition, food preferences, budget, cooking experience, and health condition. This user information set is entered into the device and sent as is to the server. The input data is packaged in JSON format or similar and sent to the server via a secure API.

[1308] Step 2:

[1309] The server analyzes the user information received via a secure API and stores it in a database. It analyzes the received data to generate a user profile and stores the profile information in a database, making the user information available for subsequent processing.

[1310] Step 3:

[1311] The server calls the API at specific time intervals to obtain store information such as store inventory, prices, expiration dates, and featured products. This obtains the latest store information. The obtained store information is then retrieved again through a secure API, and the server analyzes the data and saves it in a database. This saves the latest information on inventory, prices, expiration dates, etc.

[1312] Step 4:

[1313] The server generates a recipe by calling the generative AI model based on the user information and store information. It then generates a prompt for the generative AI model and sends a request to the AI ​​using that prompt. For example, it generates the following prompt:

[1314] User profile: {'family': 'Family of 4', 'food_pref': 'Japanese food', 'budget': '5000 yen', 'cooking_experience': 'Intermediate', 'health_status': 'None in particular'}

[1315] Store inventory: {'Mackerel': '10', 'Chinese cabbage': '15', 'Tofu': '20', 'Green onion': '25', 'Soy sauce': '30'}

[1316] Use this information to generate the best recipe possible.

[1317] The server analyzes the generated recipe and stores it in a database.

[1318] Step 5:

[1319] The user's device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients (location in the store) to the user. The input data is the recipe information selected by the user, and the output data is the specific cooking steps, shopping list, and in-store directions.

[1320] Step 6:

[1321] The server identifies products that are close to their expiration date or are in excess of stock from store information, and regenerates recipes that prioritize the use of these products. This generates recipes that can utilize products that are close to their expiration date or are in excess of stock, and sends them to the terminal. The user is also notified again.

[1322] Step 7:

[1323] The server identifies plus-one items such as beverages and confectionery based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the suggested plus-one items to the user and allows them to choose whether to add them to their shopping list. If the user chooses to add them, the information is sent to the server and the shopping list is updated.

[1324] Step 8:

[1325] When a food manufacturer provides advertising campaign information to the server, the server invokes the generative AI model to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipe and displays it to encourage them to purchase it. If the user adds the advertised product to their shopping list, that information is sent to the server and the shopping list is updated.

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

[1327] This invention is a system that reduces food waste and promotes sales by generating optimal recipes based on user information and store information, and then using an emotion engine to make suggestions based on the user's emotions. Specifically, this system is configured and operates as follows.

[1328] System Configuration

[1329] This system, "Smart Basket," consists of a user device, a server, a database, and an emotion engine. The user device is a smartphone or tablet, which communicates with the server to send and receive information. The server runs a program incorporating generative AI and an emotion engine to generate recipes and analyze user emotions. User information and store information is stored in the database, which the server accesses to obtain the necessary information.

[1330] Program processing

[1331] Obtaining user information

[1332] Users log in to the "Smart Basket" app and enter information such as family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to the server, which stores it in a database and creates a user profile.

[1333] Obtaining store information

[1334] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database.

[1335] Generating recipe candidates

[1336] The server generates a recipe by calling the recipe GPT based on the user and store information. The recipe GPT takes into account the user profile (e.g., likes Japanese food, has an egg allergy) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate the optimal recipe. The generated recipe candidates are stored in a database.

[1337] Emotion recognition and recipe adjustment

[1338] The device collects emotional data from the user's facial expressions and voice. The emotion engine analyzes this data and identifies the user's current emotion (e.g., joy, sadness, stress). The server adjusts the recipe based on the acquired emotional data and makes suggestions according to the user's emotions.

[1339] Recipe presentation and product information

[1340] The device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[1341] Proposal for unsold products

[1342] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize the use of the identified products. Recipes based on this information are also suggested to the user on the device.

[1343] Plus One Proposal

[1344] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history, preference information, and emotional data, and generates a suggestion message that it sends to the device. The device then displays the "plus one" item suggestions to the user, who can then choose whether to add them to their shopping list.

[1345] Advertisement product proposals

[1346] When a food manufacturer provides advertising campaign information to the server, the server calls the recipe GPT to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[1347] Specific examples

[1348] Example 1: Customer A's case

[1349] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[1350] 2. The device sends the input information to the server, which updates the user profile.

[1351] 3. The server retrieves the store information and stores it in the database.

[1352] 4. The server calls the recipe GPT to generate and save a "Japanese food recipe."

[1353] 5. The device collects user A's emotion data and sends it to the server.

[1354] 6. The emotion engine analyzes User A's emotions and determines, for example, that he is under high stress.

[1355] 7. Based on the emotional data obtained, the server adjusts and suggests recipes suitable for reducing stress.

[1356] 8. The device provides recipes, displays shopping lists and store directions.

[1357] 9. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[1358] 10. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[1359] Example 2: Advertising

[1360] 1. Food manufacturers provide information about new products to a server.

[1361] 2. The server calls the recipe GPT to generate a recipe containing the advertised product.

[1362] 3. The server saves the generated recipe in the database.

[1363] 4. The device collects user B's emotion data and sends it to the server.

[1364] 5. The emotion engine analyzes User B's emotions and determines that, for example, they are feeling a high level of joy.

[1365] 6. The server adjusts and proposes recipes for advertising products based on the obtained emotional data.

[1366] 7. The device notifies User B of the recipe that includes the advertised item. User B adds the suggested item to their shopping list.

[1367] The processing flow will be explained below.

[1368] Step 1:

[1369] The user logs in to the "Smart Basket" app.

[1370] Step 2:

[1371] The device prompts the user to enter information such as family composition, food preferences, budget, cooking experience, and health status.

[1372] Step 3:

[1373] The terminal transmits the input user information to the server.

[1374] Step 4:

[1375] The server stores the received user information in a database and updates the user profile.

[1376] Step 5:

[1377] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc.

[1378] Step 6:

[1379] The server analyzes the store information it has acquired and processes it as necessary (e.g., standardizing date formats, cleaning data).

[1380] Step 7:

[1381] The server stores the analyzed store information in a database.

[1382] Step 8:

[1383] The server calls the recipe manager GPT based on the user information and store information to generate a recipe.

[1384] Step 9:

[1385] The recipe GPT takes into account the user profile (e.g., likes Japanese food, allergy to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate optimal recipe candidates.

[1386] Step 10:

[1387] The server stores the generated recipes in a database for each user.

[1388] Step 11:

[1389] The device collects emotional data from the user's facial expressions, voice, etc.

[1390] Step 12:

[1391] The device transmits the collected emotion data to a server.

[1392] Step 13:

[1393] The emotion engine analyzes the user's emotion data to identify their current emotional state (e.g., joy, sadness, stress).

[1394] Step 14:

[1395] The server adjusts the recipe based on the obtained emotional data and selects the optimal recipe according to the user's emotions.

[1396] Step 15:

[1397] The device displays a notification of the tailored recipe suggestions to the user.

[1398] Step 16:

[1399] The user opens the app and sees the suggested recipes.

[1400] Step 17:

[1401] The device displays the recipe details (ingredients, instructions) and the location of the ingredients (location within the store) to the user.

[1402] Step 18:

[1403] Users select their favorite recipes and add them to their shopping list.

[1404] Step 19:

[1405] The server identifies products that are close to their expiration date or that are in excess of stock from store information.

[1406] Step 20:

[1407] The server calls the recipe manager GPT again to generate a recipe that prioritizes the use of the identified products.

[1408] Step 21:

[1409] Recipe GPT generates recipes using these products.

[1410] Step 22:

[1411] The server updates the recipe database to suggest the generated recipes to the user.

[1412] Step 23:

[1413] The device notifies the user of suggestions for additional products (e.g., drinks or sweets).

[1414] Step 24:

[1415] The server obtains the information about the advertised products and calls the recipe GPT to generate a recipe that includes the advertised products.

[1416] Step 25:

[1417] Recipe GPT generates recipes that include the advertised products.

[1418] Step 26:

[1419] The server stores the advertised recipes in a database and suggests them to users who meet certain conditions.

[1420] Step 27:

[1421] The terminal notifies the user of the advertised recipe and encourages them to make a purchase.

[1422] Example 2

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

[1424] In today's consumer society, there is a need to efficiently reduce food waste and increase consumer purchasing power, but to achieve this, it is necessary to make proposals that respond to the diverse needs and emotions of consumers.In addition, it is also important to reflect store inventory information in real time, appropriately utilize products that are approaching their expiration date, and efficiently promote advertised products.

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

[1426] In this invention, the server includes means for inputting user information, means for acquiring store information, means for generating recipes based on the user information and the store information, means for presenting the generated recipes to the user, means for suggesting ingredients needed from the recipes, means for collecting emotion data, means for analyzing the collected emotion data and adjusting the recipes based on the user's emotion, and means for suggesting plus-one products based on the user's purchase history and preference information. This makes it possible to provide appropriate recipe suggestions and purchasing processes according to the needs and emotions of each user, thereby effectively reducing food waste and promoting sales.

[1427] "User information" is personal data of the user, including family composition, food preferences, budget, cooking experience, health condition, and the like.

[1428] "Store information" is data obtained from the store, and includes inventory information, prices, expiration dates, featured products, and the like.

[1429] A "recipe" is a list of instructions and ingredients for preparing a particular dish or meal.

[1430] "Emotion data" is data that indicates the psychological state of the user, obtained from facial expressions, voice, etc.

[1431] "Plus one product" refers to an additional product such as a drink or snack that is suggested in addition to the product that the user is primarily intending to purchase.

[1432] "Advertised products" are products that are the subject of a specific campaign and are proposed by companies or manufacturers for promotional purposes.

[1433] An "emotion engine" refers to a program or function that analyzes emotional data collected from a user and identifies the user's psychological state.

[1434] A "generative AI model" refers to an artificial intelligence algorithm that generates appropriate output based on input data.

[1435] An "API" is an interface that allows applications to connect with other services and databases.

[1436] "Database" refers to a structured collection of data for efficiently storing and managing data used within a system.

[1437] A "terminal" is a device that a user can directly operate, and includes a smartphone, tablet, etc.

[1438] A "server" refers to a combination of a computer and software for managing the entire system and processing data.

[1439] This invention is a recipe suggestion system for reducing food waste and promoting sales, and is composed of a user terminal, a server, a database, and an emotion engine. This system automatically collects user information, acquires store information, and generates optimal recipes based on this information and suggests them to the user.

[1440] Registering user information

[1441] Users log in to the "Smart Basket" app from their smartphones, tablets, or other devices and enter information such as their family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the device to the server, which then stores the received information in a database and creates a user profile.

[1442] Obtaining store information

[1443] The server uses the API at specific intervals (e.g., every hour) to retrieve store inventory information, prices, expiration dates, featured products, etc. The retrieved information is analyzed by the server and stored in a database. This data is later used to generate recipes.

[1444] Generating recipe candidates

[1445] The server calls the generative AI model (GPT for recipes) based on the user profile and store information to generate the optimal recipe. For example, if a user prefers Japanese food but is allergic to eggs, the generative AI model will generate recipes using mackerel, Chinese cabbage, and tofu based on the store's inventory. The generated recipe candidates are saved in a database.

[1446] Emotion recognition and recipe adjustment

[1447] The device collects emotional data from the user's facial expressions and voice and sends it to the server. The server then uses an emotion engine to analyze the emotional data and identify the user's current emotional state. For example, if the user is feeling stressed, the server adjusts the recipes it has generated and suggests recipes that are suitable for reducing stress.

[1448] Recipe presentation and product information

[1449] The device displays a notification of the recipe suggestion to the user. When the user confirms the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[1450] Proposal for unsold products

[1451] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and regenerates recipes that prioritize these items. This new recipe is also suggested to the user on their device.

[1452] Plus one product proposal

[1453] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history, preference information, and emotional data. The generated suggestion message is sent from the server to the terminal, and the "plus one" item suggestion is displayed to the user. The user can choose whether to add it to their shopping list.

[1454] Advertisement product proposals

[1455] When a food manufacturer provides information about a new product to the server, the server invokes a generative AI model (GPT for recipes) to generate a recipe that includes the advertised product. This new recipe is then provided to users who meet certain conditions. The device notifies the user of the advertised recipe, allowing them to consider purchasing it.

[1456] Specific examples

[1457] Example 1: Customer A's case

[1458] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[1459] 2. The device sends the input information to the server, which updates the user profile.

[1460] 3. The server retrieves the store information and stores it in the database.

[1461] 4. The server calls the generative AI model (GPT for recipes) to generate and save a "Japanese food recipe."

[1462] 5. The device collects user A's emotion data and sends it to the server.

[1463] 6. The emotion engine analyzes User A's emotions and determines, for example, that he is under high stress.

[1464] 7. Based on the emotional data obtained, the server adjusts and suggests recipes suitable for reducing stress.

[1465] 8. The device provides recipes, displays shopping lists and store directions.

[1466] 9. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[1467] 10. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[1468] Prompt Sentence Examples

[1469] 1. Basic recipe generation:

[1470] "Generate new recipes taking into account the user profile (e.g., I like Japanese food, I'm allergic to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu)."

[1471] 2. Adjust recipes according to emotions:

[1472] "Generate relaxing Japanese food recipes for users who are under a lot of stress."

[1473] 3. Disposal of unsold items:

[1474] "Please generate recipes using products that are close to their expiration date (e.g., tofu, mackerel)."

[1475] 4. Recipes containing the advertised product:

[1476] "Generate recipes that include new products from food manufacturers (e.g., specific seasonings)."

[1477] This system provides recipe suggestions and purchasing processes that respond to users' diverse needs and emotions, making it possible to effectively reduce food waste and promote sales.

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

[1479] Step 1: Register user information

[1480] Users log in to the app from a device such as a smartphone or tablet and enter information such as their family composition, food preferences, budget, cooking experience, and health condition. The entered information is sent from the device to the server. The server stores the received information in a database and creates a user profile. This enables the system to suggest recipes tailored to each individual user. The input is a form of user information, and the output is the user profile in the database.

[1481] Step 2: Get store information

[1482] The server uses the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database. This data is later used for recipe generation and inventory management. The input is the API response, and the output is the store information in the database.

[1483] Step 3: Generate recipe candidates

[1484] The server calls the generative AI model (GPT for recipes) based on the user profile and store information to generate the optimal recipe. For example, if the user prefers Japanese food and is allergic to eggs, the generative AI model will generate a recipe using mackerel, Chinese cabbage, and tofu based on the store's inventory. The generated recipe candidates are stored in a database. The input is user and store data, and the output is the generated recipe.

[1485] Step 4: Emotion recognition and recipe adjustment

[1486] The device collects emotional data from the user's facial expressions and voice and sends it to the server. The server then uses an emotion engine to analyze the emotional data and identify the user's current emotional state. For example, if the user is feeling stressed, the server adjusts the recipes it has generated and suggests recipes that are suitable for reducing stress. The input is facial expressions and voice, and the output is the user's emotional state.

[1487] Step 5: Present the recipe and introduce the product

[1488] The device displays a notification of a recipe suggestion to the user. When the user confirms the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the device. The input is the user's selection, and the output is the display content and the shopping list.

[1489] Step 6: Propose unsold items

[1490] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and regenerates recipes that prioritize these items. These new recipes are also suggested to users on their devices. This allows for products with low demand to be sold. The input is stock information, and the output is the regenerated recipe.

[1491] Step 7: Propose a Plus One Product

[1492] The server identifies plus-one products such as beverages and confectionery based on the user's purchase history, preference information, and emotional data. The generated suggestion message is sent from the server to the terminal, and the plus-one product suggestion is displayed to the user. The user can choose whether to add this to their shopping list. The input is the purchase history and emotional data, and the output is the suggestion message.

[1493] Step 8: Propose advertising products

[1494] When a food manufacturer provides information about new products and advertising campaigns to the server, the server calls a generative AI model (GPT for recipes) to generate recipes that include the advertised products based on that information. These new recipes are then provided to users who meet certain conditions. The device notifies the user of the advertised recipe, allowing them to consider purchasing it. The input is new product information, and the output is a recipe that includes the advertisement.

[1495] (Application example 2)

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

[1497] Conventional recipe suggestion systems suggest recipes based on a user's food preferences and health status, but do not take into account emotions or real-time store information, which limits their effectiveness in increasing user satisfaction and reducing food waste. This invention solves the problem of more effectively reducing food waste and promoting sales by generating and suggesting optimal recipes based on the user's emotions and real-time store information.

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

[1499] In this invention, the server includes means for inputting user information, means for acquiring store information, means for generating a recipe based on the user information and the store information, means for presenting the generated recipe to the user, means for indicating ingredients needed from the recipe, means for recognizing the user's emotions, and means for adjusting the recipe in accordance with the emotions. This makes it possible to propose optimal recipes taking the user's emotions into consideration, thereby improving user satisfaction, reducing food waste, and promoting store sales.

[1500] "User information" refers to information entered by the user, such as family composition, food preferences, budget, cooking experience, and health condition.

[1501] "Store information" refers to information acquired in real time, such as store inventory, prices, expiration dates, and featured products.

[1502] A "recipe" is a list of cooking procedures and necessary ingredients generated based on user information and store information.

[1503] "User's emotion" refers to an emotional state recognized from the user's facial expression, voice, etc., and includes, for example, joy, sadness, stress, etc.

[1504] An "emotion engine" is software or hardware for analyzing a user's emotion data and identifying the user's current emotion.

[1505] A "smartphone" is a portable communication device that a user uses to run applications.

[1506] "Generative AI" is an artificial intelligence model that generates optimal recipes based on user and store information.

[1507] "Navigation" is a function that provides directions for users to obtain the ingredients they need within the store.

[1508] The present invention is a system that generates optimal recipes based on "user information" and "store information," and then uses an "emotion engine" to make suggestions based on the user's emotions. The system is composed of a user terminal, a server, and a database, and is operated using a smartphone application. Specific embodiments are described below.

[1509] System Configuration

[1510] User terminal

[1511] The user device is primarily a smartphone. Once the user installs the app and logs in, they can input and save their "user information" such as their family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to a server and stored in a database.

[1512] server

[1513] The server is the main component that runs the program, which includes the following functions:

[1514] 1. Saving user information: The server saves the user information sent from the user terminal in a database and creates a user profile.

[1515] 2. Obtaining store information: The server periodically obtains "store information" such as store inventory, prices, expiration dates, and featured products through the API and stores it in a database.

[1516] 3. Recipe generation: The server generates the optimal recipe using a "generative AI model" based on user and store information. For example, OpenAI's GPT-4 is used for generation.

[1517] 4. Emotion analysis: The server analyzes the emotion data sent from the user's device using an "emotion engine" to identify the user's current emotion.

[1518] 5. Recipe adjustment: Based on the emotional data, the optimal recipe is readjusted and suggested to the user.

[1519] Database

[1520] The database stores and manages user information, store information, generated recipes, and the like.

[1521] Operation procedure and data processing flow

[1522] 1. Enter and save user information

[1523] The user logs in to the smartphone application and enters the required information.

[1524] The entered information is sent from the terminal to the server and stored in a database.

[1525] 2. Obtaining store information

[1526] The server periodically retrieves store inventory and price information from the API.

[1527] Save the acquired store information in the database.

[1528] 3. Recipe generation and suggestions

[1529] The server calls a generative AI model based on user information and store information and generates a recipe.

[1530] The generated recipes are stored in a database and suggested to users.

[1531] 4. Sentiment analysis and recipe adjustment

[1532] The emotion engine analyzes emotions based on facial expressions and voice data sent from the user's device.

[1533] Based on the obtained emotional data, the server readjusts the recipe and presents it to the user.

[1534] Specific examples

[1535] Example 1: Customer A's case

[1536] 1. User A logs in to the smartphone app and enters their food preferences and health status.

[1537] 2. The server retrieves the store's inventory information and stores it in a database.

[1538] 3. The server uses the generative AI model to generate a "Japanese food recipe."

[1539] 4. Analyze the user's emotional data (e.g., stress) and adjust the recipe accordingly.

[1540] 5. The smartphone app suggests the best recipe for User A and provides guidance on where to buy the necessary ingredients.

[1541] Prompt Sentence Examples

[1542] User Profile:

[1543] I like Japanese food

[1544] Egg allergy

[1545] I feel stressed easily recently

[1546] Store inventory information:

[1547] The mackerel is fresh

[1548] Abundant Chinese cabbage

[1549] There is little tofu left

[1550] Generate the recipe:

[1551] Contains ingredients that help reduce stress

[1552] Easy to cook

[1553] It is Japanese food

[1554] Based on this prompt, the generative AI model generates an appropriate recipe and suggests it to the user. This embodiment makes it possible to suggest optimal recipes that take the user's emotions into consideration, thereby improving user satisfaction, reducing food waste, and promoting store sales.

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

[1556] Step 1:

[1557] A user logs in to the smartphone app and enters user information such as family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the device to the server, which then stores it in a database. This creates a user profile.

[1558] Input: User information (family composition, food preferences, budget, cooking experience, health condition)

[1559] Output: User profile stored in the database

[1560] Specific operation: Enter user information into the input form on the smartphone app screen and press the send button. The input information is sent to the server and saved in the database.

[1561] Step 2:

[1562] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained store information is analyzed by the server and stored in a database.

[1563] Input: Store information API

[1564] Output: Store information saved in the database

[1565] Specific operation: A program on the server periodically calls the store information API, analyzes the acquired data, and stores it in a database.

[1566] Step 3:

[1567] The server calls the generative AI model based on user and store information to generate optimal recipes. The generated recipes are stored in a database and presented to the user as needed.

[1568] Input: User profile, store information

[1569] Output: Generated recipe (stored in database)

[1570] Specific operation: The server inputs user information and store information into the generative AI model to generate prompt text. The generative AI model then generates the optimal recipe and stores the results in a database.

[1571] Step 4:

[1572] The user device uses a camera and microphone to collect facial and voice data from the user and transmits it to the server, which then uses an emotion engine to analyze this data and determine the user's current emotion.

[1573] Input: User's facial expression data, voice data

[1574] Output: Parsed emotion data

[1575] Specific operation: The user takes a facial expression in front of the smartphone camera or speaks into the microphone. This data is sent to the server and analyzed by the emotion engine.

[1576] Step 5:

[1577] The server readjusts the optimal recipe based on the analyzed emotional data. The readjusted recipe is sent to the user's device and presented to the user. This allows the server to suggest recipes that match the user's current emotions.

[1578] Input: emotion data, existing recipes

[1579] Output: Reworked recipe

[1580] Specific operation: The server analyzes the emotion data, regenerates or adjusts the recipe, and sends the results to the user's smartphone, where the recipe is displayed.

[1581] Step 6:

[1582] The user device automatically generates a shopping list based on the optimal recipe, and also provides navigation to the store and guides the user to the location of the ingredients they need.

[1583] Input: Reworked recipe

[1584] Output: Purchase list, store information

[1585] Specific operation: When the user views the recipe display screen of the app, a shopping list is automatically generated. The app displays the route to the sales floor and begins navigation.

[1586] Step 7:

[1587] The server identifies products that are nearing their expiration date or are in excess of stock from the store's inventory information, and generates recipes using these products. The generated recipes are sent to the user's terminal and presented as additional suggestions.

[1588] Input: Store information

[1589] Output: Inventory adjustment recipe

[1590] Specific operation: The server analyzes store information and sends prompt text to the generation AI model, prioritizing products with an approaching expiration date or overstocked items. The generated recipe is then presented to the user.

[1591] Step 8:

[1592] The server suggests additional products, such as beverages and snacks, based on the user's purchase history, preference information, and emotional data. A suggestion message is sent to the user's terminal, and the user can choose whether to add the product to their shopping list.

[1593] Input: purchase history, preference information, emotional data

[1594] Output: Additional product suggestions

[1595] Specific operation: The server analyzes purchase history and preference information, generates a list of additional products based on emotional data, and sends the list to the user's device to suggest additional purchases.

[1596] Prompt Sentence Examples

[1597] Here is an example prompt:

[1598] User Profile:

[1599] I like Japanese food

[1600] Egg allergy

[1601] I feel stressed easily recently

[1602] Store inventory information:

[1603] The mackerel is fresh

[1604] Abundant Chinese cabbage

[1605] There is little tofu left

[1606] Generate the recipe:

[1607] Contains ingredients that help reduce stress

[1608] Easy to cook

[1609] It is Japanese food

[1610] This allows for the generation of optimal recipes that take into account the user's emotions and store inventory information, reducing food waste and improving user satisfaction.

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

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

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

[1614] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1628] The present invention is a system that reduces food waste and promotes sales by generating optimal recipes based on user information and store information and presenting them to consumers. Specifically, this system is configured and operates as follows.

[1629] System Configuration

[1630] This system, "Smart Basket," consists of a user device, a server, and a database. The user device is a smartphone or tablet, which communicates with the server to send and receive information. The server runs a program incorporating generative AI to generate recipes and analyze data. User information and store information is stored in the database, which the server accesses to retrieve the necessary information.

[1631] Program processing

[1632] Obtaining user information

[1633] Users log in to the "Smart Basket" app and enter information such as family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to the server, which stores it in a database and creates a user profile.

[1634] Obtaining store information

[1635] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database.

[1636] Generating recipe candidates

[1637] The server generates a recipe by calling the recipe GPT based on the user and store information. The recipe GPT takes into account the user profile (e.g., likes Japanese food, has an egg allergy) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate the optimal recipe. The generated recipe candidates are stored in a database.

[1638] Recipe presentation and product information

[1639] The device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[1640] Proposal for unsold products

[1641] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize the use of the identified products. Recipes based on this information are also suggested to the user on the device.

[1642] Plus One Proposal

[1643] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the "plus one" item suggestion to the user, who can then choose whether to add it to their shopping list.

[1644] Advertisement product proposals

[1645] When a food manufacturer provides advertising campaign information to the server, the server calls the recipe GPT to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[1646] Specific examples

[1647] Example 1: Customer A's case

[1648] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[1649] 2. The device sends the input information to the server, which updates the user profile.

[1650] 3. The server retrieves the store information and stores it in the database.

[1651] 4. The server calls the recipe GPT to generate and save a "Japanese food recipe."

[1652] 5. The device provides the recipe to user A and displays a shopping list and store information.

[1653] 6. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[1654] 7. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[1655] Example 2: Advertising

[1656] 1. Food manufacturers provide information about new products to a server.

[1657] 2. The server calls the recipe GPT to generate a recipe containing the advertised product.

[1658] 3. The server saves the generated recipe in the database.

[1659] 4. The device notifies User B of the recipe that includes the advertised product. User B adds the suggested product to their shopping list.

[1660] The processing flow will be explained below.

[1661] Step 1:

[1662] The user logs in to the "Smart Basket" app.

[1663] Step 2:

[1664] The device prompts the user to enter information such as family composition, food preferences, budget, cooking experience, and health status.

[1665] Step 3:

[1666] The terminal transmits the input user information to the server.

[1667] Step 4:

[1668] The server stores the received user information in a database and updates the user profile.

[1669] Step 5:

[1670] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc.

[1671] Step 6:

[1672] The server analyzes the store information it has acquired and processes it as necessary (e.g., standardizing date formats, cleaning data).

[1673] Step 7:

[1674] The server stores the analyzed store information in a database.

[1675] Step 8:

[1676] The server calls the recipe manager GPT based on the user information and store information to generate a recipe.

[1677] Step 9:

[1678] The recipe manager, GPT, takes into account the customer profile (e.g., likes Japanese food, allergy to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate optimal recipe candidates.

[1679] Step 10:

[1680] The server stores the generated recipes in a database for each user.

[1681] Step 11:

[1682] The terminal displays a notification of the recipe suggestion to the user.

[1683] Step 12:

[1684] The user opens the app and sees the suggested recipes.

[1685] Step 13:

[1686] The device displays the recipe details (ingredients, instructions) and the location of the ingredients (location within the store) to the user.

[1687] Step 14:

[1688] Users select their favorite recipes and add them to their shopping list.

[1689] Step 15:

[1690] The server identifies products that are nearing expiration dates or are overstocked.

[1691] Step 16:

[1692] The server calls the recipe manager GPT again to generate a recipe that prioritizes the use of the identified products.

[1693] Step 17:

[1694] Recipe GPT generates recipes using these products.

[1695] Step 18:

[1696] The server updates the recipe database to suggest the generated recipes to the user.

[1697] Step 19:

[1698] The device notifies the user of suggestions for additional products (e.g., drinks or sweets).

[1699] Step 20:

[1700] The server obtains the information about the advertised products and calls the recipe GPT to generate a recipe that includes the advertised products.

[1701] Step 21:

[1702] Recipe GPT generates recipes that include the advertised products.

[1703] Step 22:

[1704] The server stores the advertised recipes in a database and suggests them to users who meet certain conditions.

[1705] Step 23:

[1706] The terminal notifies the user of the advertised recipe and encourages them to make a purchase.

[1707] Example 1

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

[1709] In today's food market, food waste due to expired or unsold products is a major problem. In addition, inventory management in stores is becoming increasingly complex, and there is a lack of information available to help consumers purchase ingredients efficiently. Furthermore, the need for recipe suggestions tailored to consumers' preferences and health conditions is not being met. There is a need for a system that can solve these issues.

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

[1711] In this invention, the server includes means for inputting user information, means for acquiring store information at regular time intervals, means for generating recipes using a generative AI model based on the user information and the store information, means for presenting the generated recipes to a user terminal, means for displaying to the user details of ingredients needed from the recipes and a sales area guide, means for identifying products that are close to their expiration date or are in excess of stock, regenerating recipes that prioritize the identified products, and presenting these to the user terminal, and means for identifying plus-one products based on the user's purchase history and preference information, and suggesting the identified products to the user. This makes it possible to reduce food waste and improve the consumer shopping experience.

[1712] "User information" refers to personal information provided by a user to the system, including family composition, food preferences, budget, cooking experience, health status, and the like.

[1713] "Store information" refers to data such as inventory information, prices, expiration dates, featured products, etc., related to a particular store.

[1714] "Generative AI model" refers to an artificial intelligence model used to automatically generate optimal recipes based on user and store information.

[1715] "Recipe" refers to information provided to a user that includes instructions and a list of ingredients needed to prepare a particular dish.

[1716] "User terminal" refers to a device used by a user to access the system and input or receive information, including smartphones, tablets, etc.

[1717] "Products with an approaching expiration date" refers to products whose best-before date or expiration date is approaching.

[1718] "Overstocked items" refers to items that are overstocked in a store.

[1719] "Plus one products" refer to complementary products such as beverages and snacks that are suggested for addition to the main shopping list based on the user's purchase history and preference information.

[1720] "Sales floor guide" refers to information indicating where in the store the food ingredients that the user is trying to purchase are located.

[1721] This invention is a system that reduces food waste and improves the consumer's shopping experience by generating optimal recipes based on user and store information and presenting them to the user. This system is composed of multiple components, including a user terminal, a server, and a database, and operates as follows:

[1722] System Configuration

[1723] This system consists of a user terminal, a server, and a database. The user terminal is a smartphone or tablet, and is the device through which the user inputs and receives information into the system. The server runs programs including the generative AI model and plays a central role in data analysis and recipe generation. The database stores user information and store information, and the server accesses it to obtain the necessary information.

[1724] Obtaining user information

[1725] A user logs into the "Smart Basket" app and enters information such as family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the user's device to the server. The server stores the received user information in a database and creates and updates the user profile.

[1726] Obtaining store information

[1727] The server calls the API at regular intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained information is analyzed by the server and stored in a database.

[1728] Recipe Generation

[1729] The server uses a generative AI model to generate optimal recipes based on user and store information. The recipe manager GPT creates recipes taking into account the user profile and store inventory. The generated recipe candidates are stored in a database.

[1730] Recipe presentation and product information

[1731] The user's device displays a notification of the recipe suggestion to the user. When the user confirms the notification and opens the app to check the suggested recipe, the user's device displays the recipe details (ingredients, cooking instructions) and information about where to buy the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the user's device.

[1732] Proposal for unsold products

[1733] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates a new recipe that prioritizes the use of the identified products and notifies the user's device.

[1734] Plus One Proposal

[1735] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information. It then generates a suggestion message and sends it to the user's device. The user can then review the suggested "plus one" items and choose whether to add them to their shopping list.

[1736] Specific examples

[1737] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[1738] 2. The device sends this information to the server, which updates the user profile.

[1739] 3. The server retrieves the store information and stores it in the database.

[1740] 4. The server calls the recipe GPT, generates a "Japanese food recipe", and saves it. An example prompt is as follows:

[1741] "Generate recipes using mackerel, Chinese cabbage, and tofu for a user who likes Japanese food but has an egg allergy."

[1742] 5. The device notifies user A of the recipe suggestion and displays details and sales area information.

[1743] 6. The server regenerates and suggests recipes using ingredients that are close to their expiration date.

[1744] 7. The device suggests additional items such as green tea and Japanese sweets to User A.

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

[1746] Step 1: Enter your user information

[1747] A user logs in to the "Smart Basket" app and enters information such as family composition, food preferences, budget, cooking experience, and health condition. The information entered includes the user's family composition (e.g., a family of three), food preferences (e.g., likes Japanese food), budget (e.g., 5,000 yen per week), cooking experience (e.g., intermediate), and health condition (e.g., egg allergy).

[1748] The terminal sends the input information to the server in JSON format. Here, input is the information the user enters into the terminal, and output is the JSON data sent to the server.

[1749] Step 2: Save user information

[1750] The server saves the received user information in the database. Specifically, it parses the JSON data received on the server side and inserts it into the "user_profiles" table.

[1751] Input: JSON data sent from the terminal

[1752] Output: Save data to database

[1753] Step 3: Get store information

[1754] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. Specifically, the server uses a Cron job to periodically send an HTTP GET request to the store API.

[1755] Input: API request via Cron job

[1756] Output: Obtain store information data

[1757] Step 4: Save your store information

[1758] The server analyzes the acquired store information and stores it in a database. For example, it stores inventory information in the "inventory" table.

[1759] Input: Acquired store information data

[1760] Output: Save data to database

[1761] Step 5: Generate the recipe

[1762] The server generates the optimal recipe using a generative AI model (e.g., GPT-3) based on user and store information. The prompt might be, "Generate a recipe using mackerel, Chinese cabbage, and tofu for a user who likes Japanese food but has an egg allergy."

[1763] Input: User information and store information

[1764] Output: Generated recipe data

[1765] Step 6: Save the recipe

[1766] The server saves the generated recipe information to a database. Specifically, it inserts the recipes returned by the generative AI model into the "recipes" table.

[1767] Input: Generated recipe data

[1768] Output: Save data to database

[1769] Step 7: Recipe Suggestion Notifications

[1770] The device displays a recipe suggestion notification to the user, for example, by sending a push notification using Firebase Cloud Messaging.

[1771] Input: Recipe suggestion data from the server

[1772] Output: Push notification to the user

[1773] Step 8: View Recipe Details

[1774] When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and where to buy those ingredients. For example, the information is displayed in HTML format on the recipe details screen within the app.

[1775] Input: Recipe suggestion notification that the user confirmed in the app

[1776] Output: Recipe details

[1777] Step 9: Generate a shopping list

[1778] When a user selects a recipe, a shopping list is automatically generated and displayed on the user's terminal, for example, a list of ingredients for the selected recipe.

[1779] Input: User's recipe selection

[1780] Output: Auto-generated shopping list

[1781] Step 10: Identifying products with approaching expiration dates and generating recipes

[1782] The server identifies products that are close to their expiration date or are in excess of stock from store information, and prioritizes regenerating recipes that use these products. For example, it uses an SQL query to extract products that are close to their expiration date from the "inventory" table.

[1783] Input: Store inventory information

[1784] Output: Recipe data based on products with an approaching expiration date

[1785] Step 11: Regenerated Recipe Suggestion

[1786] The device notifies the user of the regenerated recipe, for example by sending a push notification.

[1787] Input: Regenerated recipe data

[1788] Output: Push notification to the user

[1789] Step 12: Propose a Plus One Product

[1790] The server identifies plus-one products based on the user's purchase history and preference information, generates a recommendation message, and sends it to the user's device. For example, the server identifies recommended products using a machine learning model.

[1791] Input: User purchase history and preference information

[1792] Output: Plus one product suggestion message

[1793] Step 13: Check and add your Plus One items

[1794] The user checks the suggested plus-one items and selects whether to add them to the shopping list. The terminal updates the shopping list according to the user's selection.

[1795] Input: Plus One product suggestion message

[1796] Output: Updated shopping list

[1797] (Application example 1)

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

[1799] Conventional systems have difficulty proposing optimal recipes based on a user's individual preferences and household circumstances, and have been inadequate in proposing recipes that utilize products that are nearing their expiration date or that are overstocked. It has also been difficult to appropriately suggest "plus-one" products or promotional products, resulting in insufficient reduction of food waste and insufficient sales promotion. Furthermore, there is no in-store guidance to help users efficiently purchase the ingredients they need, which has led to inefficient shopping.

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

[1801] In this invention, the server includes a means for inputting user information, a means for acquiring store information, a means for generating a recipe based on the user information and the store information, a means for generating an optimal recipe using a generative AI model, a means for generating a prompt and acquiring a recipe, a means for presenting the generated recipe to the user, and a means for providing information on ingredients needed from the recipe. This allows for optimal recipe suggestions based on the user's preferences and health status. Furthermore, the server can suggest recipes using products with approaching expiration dates or overstocked items, as well as appropriate suggestions for additional products and advertised items, effectively reducing food waste and promoting sales. Furthermore, the server provides in-store guidance to help users efficiently purchase the ingredients they need, improving shopping efficiency.

[1802] "User information" is personal data such as the user's family structure, food preferences, budget, cooking experience, and health condition.

[1803] "Store information" refers to data about the store, such as store inventory, prices, expiration dates, and featured products.

[1804] The "recipe generation means" refers to a program or algorithm for creating an appropriate recipe based on user information and store information.

[1805] A "generative AI model" is a technology for generating text and information using large-scale language models and generative artificial intelligence.

[1806] A "prompt" is a question or instruction written in a specific format to be input into a generative AI model.

[1807] A "generated recipe" is a cooking procedure and ingredient list created by a generative AI model that takes into account user and store information.

[1808] The "user presentation means" refers to a device or software for displaying the generated recipe to the user.

[1809] The "ingredient guide means" is a system or method for informing the user of the location in the store of ingredients required for a recipe and a shopping list.

[1810] This invention is a system that generates optimal recipes based on user information and store information and presents them to consumers. The purpose of this system is to reduce food waste and promote sales. This system, "Smart Basket," consists of a user terminal, a server, and a database, and is specifically configured as follows:

[1811] System Configuration

[1812] User terminal

[1813] A user device refers to a device such as a smartphone or tablet. The user uses this device to access the application and enter information such as family composition, food preferences, budget, cooking experience, and health status. The entered user information is sent from the device to the server.

[1814] server

[1815] The server receives information sent from the user's device and stores it in a database. It also periodically calls an API to obtain store information such as store inventory, prices, expiration dates, and featured products. The server also calls the generative AI model and generates recipes.

[1816] Database

[1817] The database stores user and store information. The server accesses this database to obtain the necessary information and uses it to generate recipes.

[1818] Program processing

[1819] Obtaining user information

[1820] The user logs in to the app and enters the necessary information (family composition, food preferences, budget, cooking experience, health condition, etc.). The user's device sends the entered information to the server.

[1821] Obtaining store information

[1822] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained information is analyzed and stored in a database.

[1823] Generating recipe candidates

[1824] The server generates a recipe by calling a generative AI model based on the user and store information. This AI model generates the optimal recipe taking into account the user profile (e.g., "likes Japanese food") and the store's inventory (e.g., mackerel, Chinese cabbage, tofu). An example of this prompt is as follows:

[1825] User profile: {'family': 'Family of 4', 'food_pref': 'Japanese food', 'budget': '5000 yen', 'cooking_experience': 'Intermediate', 'health_status': 'None in particular'}

[1826] Store inventory: {'Mackerel': '10', 'Chinese cabbage': '15', 'Tofu': '20', 'Green onion': '25', 'Soy sauce': '30'}

[1827] Use this information to generate the best recipe possible.

[1828] Recipe presentation and product information

[1829] The user's device will display a notification of the suggested recipe to the user. When the user opens the app and checks the suggested recipe, the device will display the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list will be automatically generated and displayed on the device.

[1830] Proposal for unsold products

[1831] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize these items. Recipes based on this information are also suggested to the user on their device.

[1832] Plus One Proposal

[1833] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the "plus one" item suggestion to the user, who can then choose whether to add it to their shopping list.

[1834] Advertisement product proposals

[1835] When a food manufacturer provides advertising campaign information to the server, the server invokes the generative AI model to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[1836] This allows users to find the most suitable recipes, making shopping more efficient and eco-friendly. It also offers appropriate suggestions for plus-one products and promotional items, which is expected to have a positive effect on sales promotion.

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

[1838] Step 1:

[1839] A user logs in to the application using a smartphone device. The user enters user information such as family composition, food preferences, budget, cooking experience, and health condition. This user information set is entered into the device and sent as is to the server. The input data is packaged in JSON format or similar and sent to the server via a secure API.

[1840] Step 2:

[1841] The server analyzes the user information received via a secure API and stores it in a database. It analyzes the received data to generate a user profile and stores the profile information in a database, making the user information available for subsequent processing.

[1842] Step 3:

[1843] The server calls the API at specific time intervals to obtain store information such as store inventory, prices, expiration dates, and featured products. This obtains the latest store information. The obtained store information is then retrieved again through a secure API, and the server analyzes the data and saves it in a database. This saves the latest information on inventory, prices, expiration dates, etc.

[1844] Step 4:

[1845] The server generates a recipe by calling the generative AI model based on the user information and store information. It then generates a prompt for the generative AI model and sends a request to the AI ​​using that prompt. For example, it generates the following prompt:

[1846] User profile: {'family': 'Family of 4', 'food_pref': 'Japanese food', 'budget': '5000 yen', 'cooking_experience': 'Intermediate', 'health_status': 'None in particular'}

[1847] Store inventory: {'Mackerel': '10', 'Chinese cabbage': '15', 'Tofu': '20', 'Green onion': '25', 'Soy sauce': '30'}

[1848] Use this information to generate the best recipe possible.

[1849] The server analyzes the generated recipe and stores it in a database.

[1850] Step 5:

[1851] The user's device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients (location in the store) to the user. The input data is the recipe information selected by the user, and the output data is the specific cooking steps, shopping list, and in-store directions.

[1852] Step 6:

[1853] The server identifies products that are close to their expiration date or are in excess of stock from store information, and regenerates recipes that prioritize the use of these products. This generates recipes that can utilize products that are close to their expiration date or are in excess of stock, and sends them to the terminal. The user is also notified again.

[1854] Step 7:

[1855] The server identifies plus-one items such as beverages and confectionery based on the user's purchase history and preference information, generates a suggestion message, and sends it to the terminal. The terminal displays the suggested plus-one items to the user and allows them to choose whether to add them to their shopping list. If the user chooses to add them, the information is sent to the server and the shopping list is updated.

[1856] Step 8:

[1857] When a food manufacturer provides advertising campaign information to the server, the server invokes the generative AI model to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipe and displays it to encourage them to purchase it. If the user adds the advertised product to their shopping list, that information is sent to the server and the shopping list is updated.

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

[1859] This invention is a system that reduces food waste and promotes sales by generating optimal recipes based on user information and store information, and then using an emotion engine to make suggestions based on the user's emotions. Specifically, this system is configured and operates as follows.

[1860] System Configuration

[1861] This system, "Smart Basket," consists of a user device, a server, a database, and an emotion engine. The user device is a smartphone or tablet, which communicates with the server to send and receive information. The server runs a program incorporating generative AI and an emotion engine to generate recipes and analyze user emotions. User information and store information is stored in the database, which the server accesses to obtain the necessary information.

[1862] Program processing

[1863] Obtaining user information

[1864] Users log in to the "Smart Basket" app and enter information such as family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to the server, which stores it in a database and creates a user profile.

[1865] Obtaining store information

[1866] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database.

[1867] Generating recipe candidates

[1868] The server generates a recipe by calling the recipe GPT based on the user and store information. The recipe GPT takes into account the user profile (e.g., likes Japanese food, has an egg allergy) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate the optimal recipe. The generated recipe candidates are stored in a database.

[1869] Emotion recognition and recipe adjustment

[1870] The device collects emotional data from the user's facial expressions and voice. The emotion engine analyzes this data and identifies the user's current emotion (e.g., joy, sadness, stress). The server adjusts the recipe based on the acquired emotional data and makes suggestions according to the user's emotions.

[1871] Recipe presentation and product information

[1872] The device displays a notification of a recipe suggestion to the user. When the user opens the app and checks the suggested recipe, the device displays the recipe details (ingredients, instructions) and the location of the ingredients (in-store location) to the user. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[1873] Proposal for unsold products

[1874] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and then generates new recipes that prioritize the use of the identified products. Recipes based on this information are also suggested to the user on the device.

[1875] Plus One Proposal

[1876] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history, preference information, and emotional data, and generates a suggestion message that it sends to the device. The device then displays the "plus one" item suggestions to the user, who can then choose whether to add them to their shopping list.

[1877] Advertisement product proposals

[1878] When a food manufacturer provides advertising campaign information to the server, the server calls the recipe GPT to generate recipes that include the advertised products. The generated recipes are stored in a database and suggested to users who meet certain conditions. The device notifies the user of the advertised recipes and displays them to encourage them to purchase.

[1879] Specific examples

[1880] Example 1: Customer A's case

[1881] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[1882] 2. The device sends the input information to the server, which updates the user profile.

[1883] 3. The server retrieves the store information and stores it in the database.

[1884] 4. The server calls the recipe GPT to generate and save a "Japanese food recipe."

[1885] 5. The device collects user A's emotion data and sends it to the server.

[1886] 6. The emotion engine analyzes User A's emotions and determines, for example, that he is under high stress.

[1887] 7. Based on the emotional data obtained, the server adjusts and suggests recipes suitable for reducing stress.

[1888] 8. The device provides recipes, displays shopping lists and store directions.

[1889] 9. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[1890] 10. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[1891] Example 2: Advertising

[1892] 1. Food manufacturers provide information about new products to a server.

[1893] 2. The server calls the recipe GPT to generate a recipe containing the advertised product.

[1894] 3. The server saves the generated recipe in the database.

[1895] 4. The device collects user B's emotion data and sends it to the server.

[1896] 5. The emotion engine analyzes User B's emotions and determines that, for example, they are feeling a high level of joy.

[1897] 6. The server adjusts and proposes recipes for advertising products based on the obtained emotional data.

[1898] 7. The device notifies User B of the recipe that includes the advertised item. User B adds the suggested item to their shopping list.

[1899] The processing flow will be explained below.

[1900] Step 1:

[1901] The user logs in to the "Smart Basket" app.

[1902] Step 2:

[1903] The device prompts the user to enter information such as family composition, food preferences, budget, cooking experience, and health status.

[1904] Step 3:

[1905] The terminal transmits the input user information to the server.

[1906] Step 4:

[1907] The server stores the received user information in a database and updates the user profile.

[1908] Step 5:

[1909] The server calls an API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc.

[1910] Step 6:

[1911] The server analyzes the store information it has acquired and processes it as necessary (e.g., standardizing date formats, cleaning data).

[1912] Step 7:

[1913] The server stores the analyzed store information in a database.

[1914] Step 8:

[1915] The server calls the recipe manager GPT based on the user information and store information to generate a recipe.

[1916] Step 9:

[1917] The recipe GPT takes into account the user profile (e.g., likes Japanese food, allergy to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu) to generate optimal recipe candidates.

[1918] Step 10:

[1919] The server stores the generated recipes in a database for each user.

[1920] Step 11:

[1921] The device collects emotional data from the user's facial expressions, voice, etc.

[1922] Step 12:

[1923] The device transmits the collected emotion data to a server.

[1924] Step 13:

[1925] The emotion engine analyzes the user's emotion data to identify their current emotional state (e.g., joy, sadness, stress).

[1926] Step 14:

[1927] The server adjusts the recipe based on the obtained emotional data and selects the optimal recipe according to the user's emotions.

[1928] Step 15:

[1929] The device displays a notification of the tailored recipe suggestions to the user.

[1930] Step 16:

[1931] The user opens the app and sees the suggested recipes.

[1932] Step 17:

[1933] The device displays the recipe details (ingredients, instructions) and the location of the ingredients (location within the store) to the user.

[1934] Step 18:

[1935] Users select their favorite recipes and add them to their shopping list.

[1936] Step 19:

[1937] The server identifies products that are close to their expiration date or that are in excess of stock from store information.

[1938] Step 20:

[1939] The server calls the recipe manager GPT again to generate a recipe that prioritizes the use of the identified products.

[1940] Step 21:

[1941] Recipe GPT generates recipes using these products.

[1942] Step 22:

[1943] The server updates the recipe database to suggest the generated recipes to the user.

[1944] Step 23:

[1945] The device notifies the user of suggestions for additional products (e.g., drinks or sweets).

[1946] Step 24:

[1947] The server obtains the information about the advertised products and calls the recipe GPT to generate a recipe that includes the advertised products.

[1948] Step 25:

[1949] Recipe GPT generates recipes that include the advertised products.

[1950] Step 26:

[1951] The server stores the advertised recipes in a database and suggests them to users who meet certain conditions.

[1952] Step 27:

[1953] The terminal notifies the user of the advertised recipe and encourages them to make a purchase.

[1954] Example 2

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

[1956] In today's consumer society, there is a need to efficiently reduce food waste and increase consumer purchasing power, but to achieve this, it is necessary to make proposals that respond to the diverse needs and emotions of consumers.In addition, it is also important to reflect store inventory information in real time, appropriately utilize products that are approaching their expiration date, and efficiently promote advertised products.

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

[1958] In this invention, the server includes means for inputting user information, means for acquiring store information, means for generating recipes based on the user information and the store information, means for presenting the generated recipes to the user, means for suggesting ingredients needed from the recipes, means for collecting emotion data, means for analyzing the collected emotion data and adjusting the recipes based on the user's emotion, and means for suggesting plus-one products based on the user's purchase history and preference information. This makes it possible to provide appropriate recipe suggestions and purchasing processes according to the needs and emotions of each user, thereby effectively reducing food waste and promoting sales.

[1959] "User information" is personal data of the user, including family composition, food preferences, budget, cooking experience, health condition, and the like.

[1960] "Store information" is data obtained from the store, and includes inventory information, prices, expiration dates, featured products, and the like.

[1961] A "recipe" is a list of instructions and ingredients for preparing a particular dish or meal.

[1962] "Emotion data" is data that indicates the psychological state of the user, obtained from facial expressions, voice, etc.

[1963] "Plus one product" refers to an additional product such as a drink or snack that is suggested in addition to the product that the user is primarily intending to purchase.

[1964] "Advertised products" are products that are the subject of a specific campaign and are proposed by companies or manufacturers for promotional purposes.

[1965] An "emotion engine" refers to a program or function that analyzes emotional data collected from a user and identifies the user's psychological state.

[1966] A "generative AI model" refers to an artificial intelligence algorithm that generates appropriate output based on input data.

[1967] An "API" is an interface that allows applications to connect with other services and databases.

[1968] "Database" refers to a structured collection of data for efficiently storing and managing data used within a system.

[1969] A "terminal" is a device that a user can directly operate, and includes a smartphone, tablet, etc.

[1970] A "server" refers to a combination of a computer and software for managing the entire system and processing data.

[1971] This invention is a recipe suggestion system for reducing food waste and promoting sales, and is composed of a user terminal, a server, a database, and an emotion engine. This system automatically collects user information, acquires store information, and generates optimal recipes based on this information and suggests them to the user.

[1972] Registering user information

[1973] Users log in to the "Smart Basket" app from their smartphones, tablets, or other devices and enter information such as their family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the device to the server, which then stores the received information in a database and creates a user profile.

[1974] Obtaining store information

[1975] The server uses the API at specific intervals (e.g., every hour) to retrieve store inventory information, prices, expiration dates, featured products, etc. The retrieved information is analyzed by the server and stored in a database. This data is later used to generate recipes.

[1976] Generating recipe candidates

[1977] The server calls the generative AI model (GPT for recipes) based on the user profile and store information to generate the optimal recipe. For example, if a user prefers Japanese food but is allergic to eggs, the generative AI model will generate recipes using mackerel, Chinese cabbage, and tofu based on the store's inventory. The generated recipe candidates are saved in a database.

[1978] Emotion recognition and recipe adjustment

[1979] The device collects emotional data from the user's facial expressions and voice and sends it to the server. The server then uses an emotion engine to analyze the emotional data and identify the user's current emotional state. For example, if the user is feeling stressed, the server adjusts the recipes it has generated and suggests recipes that are suitable for reducing stress.

[1980] Recipe presentation and product information

[1981] The device displays a notification of the recipe suggestion to the user. When the user confirms the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the device.

[1982] Proposal for unsold products

[1983] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and regenerates recipes that prioritize these items. This new recipe is also suggested to the user on their device.

[1984] Plus one product proposal

[1985] The server identifies "plus one" items such as beverages and snacks based on the user's purchase history, preference information, and emotional data. The generated suggestion message is sent from the server to the terminal, and the "plus one" item suggestion is displayed to the user. The user can choose whether to add it to their shopping list.

[1986] Advertisement product proposals

[1987] When a food manufacturer provides information about a new product to the server, the server invokes a generative AI model (GPT for recipes) to generate a recipe that includes the advertised product. This new recipe is then provided to users who meet certain conditions. The device notifies the user of the advertised recipe, allowing them to consider purchasing it.

[1988] Specific examples

[1989] Example 1: Customer A's case

[1990] 1. User A logs in to the app and enters their family composition, food preferences, budget, cooking experience, and health condition.

[1991] 2. The device sends the input information to the server, which updates the user profile.

[1992] 3. The server retrieves the store information and stores it in the database.

[1993] 4. The server calls the generative AI model (GPT for recipes) to generate and save a "Japanese food recipe."

[1994] 5. The device collects user A's emotion data and sends it to the server.

[1995] 6. The emotion engine analyzes User A's emotions and determines, for example, that he is under high stress.

[1996] 7. Based on the emotional data obtained, the server adjusts and suggests recipes suitable for reducing stress.

[1997] 8. The device provides recipes, displays shopping lists and store directions.

[1998] 9. The server generates recipes using ingredients that are close to their expiration date and makes additional suggestions.

[1999] 10. The device suggests additional products (e.g., green tea or Japanese sweets) to User A.

[2000] Prompt Sentence Examples

[2001] 1. Basic recipe generation:

[2002] "Generate new recipes taking into account the user profile (e.g., I like Japanese food, I'm allergic to eggs) and the store's inventory (e.g., mackerel, Chinese cabbage, tofu)."

[2003] 2. Adjust recipes according to emotions:

[2004] "Generate relaxing Japanese food recipes for users who are under a lot of stress."

[2005] 3. Disposal of unsold items:

[2006] "Please generate recipes using products that are close to their expiration date (e.g., tofu, mackerel)."

[2007] 4. Recipes containing the advertised product:

[2008] "Generate recipes that include new products from food manufacturers (e.g., specific seasonings)."

[2009] This system provides recipe suggestions and purchasing processes that respond to users' diverse needs and emotions, making it possible to effectively reduce food waste and promote sales.

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

[2011] Step 1: Register user information

[2012] Users log in to the app from a device such as a smartphone or tablet and enter information such as their family composition, food preferences, budget, cooking experience, and health condition. The entered information is sent from the device to the server. The server stores the received information in a database and creates a user profile. This enables the system to suggest recipes tailored to each individual user. The input is a form of user information, and the output is the user profile in the database.

[2013] Step 2: Get store information

[2014] The server uses the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The server analyzes the obtained information and stores it in a database. This data is later used for recipe generation and inventory management. The input is the API response, and the output is the store information in the database.

[2015] Step 3: Generate recipe candidates

[2016] The server calls the generative AI model (GPT for recipes) based on the user profile and store information to generate the optimal recipe. For example, if the user prefers Japanese food and is allergic to eggs, the generative AI model will generate a recipe using mackerel, Chinese cabbage, and tofu based on the store's inventory. The generated recipe candidates are stored in a database. The input is user and store data, and the output is the generated recipe.

[2017] Step 4: Emotion recognition and recipe adjustment

[2018] The device collects emotional data from the user's facial expressions and voice and sends it to the server. The server then uses an emotion engine to analyze the emotional data and identify the user's current emotional state. For example, if the user is feeling stressed, the server adjusts the recipes it has generated and suggests recipes that are suitable for reducing stress. The input is facial expressions and voice, and the output is the user's emotional state.

[2019] Step 5: Present the recipe and introduce the product

[2020] The device displays a notification of a recipe suggestion to the user. When the user confirms the suggested recipe, the device displays the recipe details (ingredients, cooking instructions) and the location of the ingredients. When the user selects a recipe, a shopping list is automatically generated and displayed on the device. The input is the user's selection, and the output is the display content and the shopping list.

[2021] Step 6: Propose unsold items

[2022] The server uses store information to identify products that are nearing their expiration date or are in excess of stock, and regenerates recipes that prioritize these items. These new recipes are also suggested to users on their devices. This allows for products with low demand to be sold. The input is stock information, and the output is the regenerated recipe.

[2023] Step 7: Propose a Plus One Product

[2024] The server identifies plus-one products such as beverages and confectionery based on the user's purchase history, preference information, and emotional data. The generated suggestion message is sent from the server to the terminal, and the plus-one product suggestion is displayed to the user. The user can choose whether to add this to their shopping list. The input is the purchase history and emotional data, and the output is the suggestion message.

[2025] Step 8: Propose advertising products

[2026] When a food manufacturer provides information about new products and advertising campaigns to the server, the server calls a generative AI model (GPT for recipes) to generate recipes that include the advertised products based on that information. These new recipes are then provided to users who meet certain conditions. The device notifies the user of the advertised recipe, allowing them to consider purchasing it. The input is new product information, and the output is a recipe that includes the advertisement.

[2027] (Application example 2)

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

[2029] Conventional recipe suggestion systems suggest recipes based on a user's food preferences and health status, but do not take into account emotions or real-time store information, which limits their effectiveness in increasing user satisfaction and reducing food waste. This invention solves the problem of more effectively reducing food waste and promoting sales by generating and suggesting optimal recipes based on the user's emotions and real-time store information.

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

[2031] In this invention, the server includes means for inputting user information, means for acquiring store information, means for generating a recipe based on the user information and the store information, means for presenting the generated recipe to the user, means for indicating ingredients needed from the recipe, means for recognizing the user's emotions, and means for adjusting the recipe in accordance with the emotions. This makes it possible to propose optimal recipes taking the user's emotions into consideration, thereby improving user satisfaction, reducing food waste, and promoting store sales.

[2032] "User information" refers to information entered by the user, such as family composition, food preferences, budget, cooking experience, and health condition.

[2033] "Store information" refers to information acquired in real time, such as store inventory, prices, expiration dates, and featured products.

[2034] A "recipe" is a list of cooking procedures and necessary ingredients generated based on user information and store information.

[2035] "User's emotion" refers to an emotional state recognized from the user's facial expression, voice, etc., and includes, for example, joy, sadness, stress, etc.

[2036] An "emotion engine" is software or hardware for analyzing a user's emotion data and identifying the user's current emotion.

[2037] A "smartphone" is a portable communication device that a user uses to run applications.

[2038] "Generative AI" is an artificial intelligence model that generates optimal recipes based on user and store information.

[2039] "Navigation" is a function that provides directions for users to obtain the ingredients they need within the store.

[2040] The present invention is a system that generates optimal recipes based on "user information" and "store information," and then uses an "emotion engine" to make suggestions based on the user's emotions. The system is composed of a user terminal, a server, and a database, and is operated using a smartphone application. Specific embodiments are described below.

[2041] System Configuration

[2042] User terminal

[2043] The user device is primarily a smartphone. Once the user installs the app and logs in, they can input and save their "user information" such as their family composition, food preferences, budget, cooking experience, and health status. This information is sent from the device to a server and stored in a database.

[2044] server

[2045] The server is the main component that runs the program, which includes the following functions:

[2046] 1. Saving user information: The server saves the user information sent from the user terminal in a database and creates a user profile.

[2047] 2. Obtaining store information: The server periodically obtains "store information" such as store inventory, prices, expiration dates, and featured products through the API and stores it in a database.

[2048] 3. Recipe generation: The server generates the optimal recipe using a "generative AI model" based on user and store information. For example, OpenAI's GPT-4 is used for generation.

[2049] 4. Emotion analysis: The server analyzes the emotion data sent from the user's device using an "emotion engine" to identify the user's current emotion.

[2050] 5. Recipe adjustment: Based on the emotional data, the optimal recipe is readjusted and suggested to the user.

[2051] Database

[2052] The database stores and manages user information, store information, generated recipes, and the like.

[2053] Operation procedure and data processing flow

[2054] 1. Enter and save user information

[2055] The user logs in to the smartphone application and enters the required information.

[2056] The entered information is sent from the terminal to the server and stored in a database.

[2057] 2. Obtaining store information

[2058] The server periodically retrieves store inventory and price information from the API.

[2059] Save the acquired store information in the database.

[2060] 3. Recipe generation and suggestions

[2061] The server calls a generative AI model based on user information and store information and generates a recipe.

[2062] The generated recipes are stored in a database and suggested to users.

[2063] 4. Sentiment analysis and recipe adjustment

[2064] The emotion engine analyzes emotions based on facial expressions and voice data sent from the user's device.

[2065] Based on the obtained emotional data, the server readjusts the recipe and presents it to the user.

[2066] Specific examples

[2067] Example 1: Customer A's case

[2068] 1. User A logs in to the smartphone app and enters their food preferences and health status.

[2069] 2. The server retrieves the store's inventory information and stores it in a database.

[2070] 3. The server uses the generative AI model to generate a "Japanese food recipe."

[2071] 4. Analyze the user's emotional data (e.g., stress) and adjust the recipe accordingly.

[2072] 5. The smartphone app suggests the best recipe for User A and provides guidance on where to buy the necessary ingredients.

[2073] Prompt Sentence Examples

[2074] User Profile:

[2075] I like Japanese food

[2076] Egg allergy

[2077] I feel stressed easily recently

[2078] Store inventory information:

[2079] The mackerel is fresh

[2080] Abundant Chinese cabbage

[2081] There is little tofu left

[2082] Generate the recipe:

[2083] Contains ingredients that help reduce stress

[2084] Easy to cook

[2085] It is Japanese food

[2086] Based on this prompt, the generative AI model generates an appropriate recipe and suggests it to the user. This embodiment makes it possible to suggest optimal recipes that take the user's emotions into consideration, thereby improving user satisfaction, reducing food waste, and promoting store sales.

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

[2088] Step 1:

[2089] A user logs in to the smartphone app and enters user information such as family composition, food preferences, budget, cooking experience, and health status. The entered information is sent from the device to the server, which then stores it in a database. This creates a user profile.

[2090] Input: User information (family composition, food preferences, budget, cooking experience, health condition)

[2091] Output: User profile stored in the database

[2092] Specific operation: Enter user information into the input form on the smartphone app screen and press the send button. The input information is sent to the server and saved in the database.

[2093] Step 2:

[2094] The server calls the API at specific time intervals (e.g., every hour) to obtain store inventory information, prices, expiration dates, featured products, etc. The obtained store information is analyzed by the server and stored in a database.

[2095] Input: Store information API

[2096] Output: Store information saved in the database

[2097] Specific operation: A program on the server periodically calls the store information API, analyzes the acquired data, and stores it in a database.

[2098] Step 3:

[2099] The server calls the generative AI model based on user and store information to generate optimal recipes. The generated recipes are stored in a database and presented to the user as needed.

[2100] Input: User profile, store information

[2101] Output: Generated recipe (stored in database)

[2102] Specific operation: The server inputs user information and store information into the generative AI model to generate prompt text. The generative AI model then generates the optimal recipe and stores the results in a database.

[2103] Step 4:

[2104] The user device uses a camera and microphone to collect facial and voice data from the user and transmits it to the server, which then uses an emotion engine to analyze this data and determine the user's current emotion.

[2105] Input: User's facial expression data, voice data

[2106] Output: Parsed emotion data

[2107] Specific operation: The user takes a facial expression in front of the smartphone camera or speaks into the microphone. This data is sent to the server and analyzed by the emotion engine.

[2108] Step 5:

[2109] The server readjusts the optimal recipe based on the analyzed emotional data. The readjusted recipe is sent to the user's device and presented to the user. This allows the server to suggest recipes that match the user's current emotions.

[2110] Input: emotion data, existing recipes

[2111] Output: Reworked recip...

Claims

1. a means for inputting user information; A means for acquiring store information; a means for generating a recipe based on the user information and the store information; A means for presenting the generated recipe to a user; The system includes a means for providing guidance on the ingredients required from the recipe.

2. The system according to claim 1 , further comprising means for identifying products that are close to their expiration date and generating a recipe that gives priority to using the identified products.

3. The system according to claim 1, further comprising means for suggesting a plus-one product such as a beverage or a confectionery item.

Images