System

Abstract

A system is provided.SOLUTION: This system includes a means for inputting information necessary for planning from a user terminal, a means for transmitting the inputted information to a server, a means for generating a plan on the basis of the information received by the server, a means for analyzing the generated plan and pointing out an ambiguous expression or an unclear target, and a means for improving the analyzed plan and returning it to the user terminal.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] Planning is important for many organizations, and the quality of the planning process is directly linked to the efficiency and success of work. However, there is a skill gap between those who are good at planning and those who are not, which can lead to inconsistencies in project progress and results. Furthermore, plans can be ambiguous and contain unclear goals, making them difficult to execute. For this reason, there is a need for a method that allows anyone to easily create high-quality plans. [Means for solving the problem]

[0005] The present invention provides a system that uses a generation AI to generate specific plans based on the user's input information by inputting the information necessary for planning from a user terminal and sending that information to a server. This system further analyzes the generated plan and has the function of pointing out ambiguous expressions and unclear goals. The system improves the plan based on the analysis results and returns the improved plan to the user terminal, allowing the user to easily create high-quality plans. The system also learns from past planning data and analyzes the factors behind success or failure, improving the accuracy of plan generation and improvement.

[0006] A "user terminal" is a device for inputting information required for planning and transmitting that information to a server.

[0007] A "server" is a central processing unit that receives information sent from user terminals and generates and analyzes plans.

[0008] "Planning" is the process of setting specific steps and goals necessary to progress a project or task.

[0009] "Generative AI" is artificial intelligence that automatically creates plans based on data provided by the user.

[0010] "Analysis" is the process of checking the contents of the generated plan, pointing out ambiguous expressions and unclear goals, and making improvements.

[0011] "Past planning data" refers to information about previously created plans, and is data used to train the AI ​​and improve the plans.

[0012] "Ambiguous expressions" refer to expressions or content that lack specificity or clarity.

[0013] An "unclear goal" refers to a goal for which the criteria for achievement and the means for achieving the goal are unclear.

[0014] "User" refers to the individual or organization that inputs information for planning purposes. [Brief explanation of the drawings]

[0015] [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

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

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

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

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

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

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

[0022] 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."

[0023] [First embodiment]

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

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

[0026] 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).

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

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

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

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

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

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

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

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

[0035] 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."

[0036] This invention relates to a planning support system that uses generative AI. This system allows users to input the information necessary for planning, generates a specific plan based on that information, and analyzes and further improves the generated plan.

[0037] First, the user enters the information required for planning (e.g., project name, start date, and end date) from a user device such as a web browser or application. The entered data is converted into a standard format such as JSON and sent to the server.

[0038] The server receives data sent from the user's device and first uses a generation AI to generate a specific plan. Based on the data provided by the user, the generation AI sets out detailed details for each phase and milestone of the project. This plan generation process takes into account not only the planning method for new projects, but also factors for success and failure learned from past planning data.

[0039] The server then analyzes the generated plan. During this analysis, it detects ambiguous expressions and unclear goals in the plan and generates feedback to improve them. For example, it may say, "The deadline for this task is vague. Please set a concrete deadline." It also provides suggestions for improvement. This analysis and refinement step increases the feasibility of the plan.

[0040] The improved plan data is then converted back into a standard format such as JSON and sent back to the user's device. The user can then review the returned data and confirm it as the final plan, enabling them to create efficient, high-quality plans.

[0041] A specific use case could be as follows: When a company's project manager creates a development plan for a new product, the user inputs basic information such as the product name, start date, end date, and major milestones from their device. The server receives this information and uses generative AI to create a detailed development schedule. The server then analyzes the generated plan, points out ambiguities and unclear goals, and provides specific suggestions for improvement. Finally, the improved plan is sent back to the user's device, and the project manager uses it to proceed with the project.

[0042] In this way, the present invention supports users who are not good at planning to easily create efficient, high-quality plans, thereby standardizing planning skills throughout the organization.

[0043] The processing flow will be explained below.

[0044] Step 1:

[0045] The user enters the information required for planning (e.g., project name, start date, end date) into a web browser or application input form. The entered information is temporarily stored in the device's memory.

[0046] Step 2:

[0047] The device detects that the user has clicked the "Submit" button on the input form. This triggers a process to convert the form data into JSON format. The converted data is then sent to the server as a POST request using the HTTPS protocol.

[0048] Step 3:

[0049] The server receives the POST request sent from the device. The server extracts the JSON data from the request, parses it, and starts the plan generation process based on the information provided by the user (project name, start date, end date, etc.).

[0050] Step 4:

[0051] The server then triggers a generative AI based on the received data, which then uses the user-provided data to automatically create a concrete plan, detailing each phase and milestone of the project.

[0052] Step 5:

[0053] The server calls the analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. For example, it might say, "The deadline for this task is vague. Please set a concrete deadline."

[0054] Step 6:

[0055] The server refines the plan based on the feedback from the analysis module, and the refined plan is converted back into JSON format.

[0056] Step 7:

[0057] The refined planning data is sent back from the server to the device, securely using the HTTPS protocol.

[0058] Step 8:

[0059] The device parses the JSON data received from the server, converts the parsed data into a user-friendly format, and displays it in a web browser or application screen. The user can then review the improved plan and make further adjustments if necessary.

[0060] This series of processes allows users to easily create efficient, high-quality plans and prepare them for execution.

[0061] Example 1

[0062] 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."

[0063] Conventional planning systems require users to manually create detailed plans and correct any ambiguities or unclear goals, which makes the process inefficient and time-consuming. Furthermore, the quality of the plans depends on the skills of the users, making it difficult to standardize them.

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

[0065] In this invention, the server includes a means for inputting information required for planning from a user terminal, a means for transmitting the input information to the server, a means for generating a specific plan using a generative AI model, a means for analyzing the generated plan and pointing out ambiguous expressions and unclear goals, and a means for improving the analyzed plan and returning it to the user terminal. This makes it possible to automate and streamline planning and standardize the quality of plans.

[0066] A "user terminal" is a computer device that allows a user to input information necessary for planning and communicate with the server.

[0067] "Means of input" refers to the methods and functions that allow users to input information required for planning into the system.

[0068] "Means for transmitting" refers to the method or function for transmitting information entered from a user terminal to a server.

[0069] "Server" is a central control device that receives information sent from user terminals and generates, analyzes, and improves plans.

[0070] A "generative AI model" is an algorithm or model that uses artificial intelligence to generate specific plans from user data.

[0071] "Means for generating specific plans" refers to methods and functions that utilize generative AI models to create detailed plans based on user-provided data.

[0072] "Means for pointing out ambiguous expressions and unclear goals" refers to a method or function for analyzing the contents of the generated plan and detecting and pointing out ambiguous or unclear parts.

[0073] "Means for improving and returning" refers to a method or function for improving the analyzed plan and transmitting the improved plan data to the user terminal.

[0074] "Means for learning from past planning data" refers to a method or function by which the server analyzes and learns from planning data generated in the past to improve the accuracy of planning.

[0075] "Means for providing feedback" refers to methods and functions for communicating to the user any problems or improvement suggestions detected based on the generated plan.

[0076] This invention relates to a planning support system that uses a generative AI model. Users input the information necessary for planning from their user terminal, and the server generates a specific plan based on that information, analyzes it, and returns the improved plan to the user terminal. This system realizes automation, efficiency, and high quality of planning.

[0077] System Overview

[0078] User Device

[0079] A user terminal is a computer device where a user inputs information required for planning and sends it to the server. The user uses a web browser or a dedicated application to input information such as the project name, start date, end date, and major milestones. For example, the user might input a prompt such as:

[0080] Example prompt sentence:

[0081] Project Name: New Product Development

[0082] Start date: 2023-11-01

[0083] End date: 2024-06-30

[0084] Major milestones:

[0085] Idea Planning: 2023-11-15

[0086] Prototype development: 2024-01-31

[0087] User test: 2024-03-15

[0088] Product launch: 2024-06-30

[0089] server

[0090] The server receives the data sent from the user device and generates a detailed plan using a generative AI model (e.g., OpenAI GPT-4). Specifically, the process proceeds as follows:

[0091] 1. Data Reception

[0092] The server receives the information sent from the user device and converts the data into a standard format such as JSON, including the project name, start date, end date, and milestone information.

[0093] 2. Plan Generation

[0094] The server uses a generative AI model to generate a specific plan based on the received data, taking into account the data provided by the user and past planning data to define each phase and milestone of the project in detail.

[0095] Specific plan generation examples:

[0096] Project "New Product Development":

[0097] Phase 1: Idea Planning (2023-11-01 ~ 2023-11-15)

[0098] Task 1: Idea Brainstorming (2023-11-02)

[0099] Task 2: Initial Investigation (2023-11-05)

[0100] Phase 2: Prototype Development (2023-11-16 ~ 2024-01-31)

[0101] Task 1: Prototype Design (2023-11-20)

[0102] Task 2: Initial prototype creation (2023-12-05)

[0103] 3. Plan analysis and feedback generation

[0104] The server analyzes the generated plan to detect ambiguous expressions and unclear goals, and generates feedback such as, "The end date for prototype development is unclear. Please specify the number of prototypes and the end conditions."

[0105] 4. Submit your feedback and improvement plan

[0106] The server sends the generated feedback back to the user's device, and the user can then modify the plan based on this feedback and finalize the plan.

[0107] To give a specific example, when a project manager at a company plans the development of a new product, he or she enters the following information from a user terminal:

[0108] Example prompt sentence:

[0109] Project Name: New Product Development

[0110] Start date: 2023-11-01

[0111] End date: 2024-06-30

[0112] Major milestones:

[0113] Idea Planning: 2023-11-15

[0114] Prototype development: 2024-01-31

[0115] User test: 2024-03-15

[0116] Product launch: 2024-06-30

[0117] The server receives this information and uses a generative AI model to create a detailed development schedule. It then analyzes the generated plan, points out ambiguities and unclear goals, and provides specific suggestions for improvement. Finally, the improved plan is returned to the user's device, and the project manager uses it to proceed with the project. In this way, the present invention helps even users who are not good at planning to easily create efficient, high-quality plans, thereby standardizing planning skills throughout the organization.

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

[0119] Step 1:

[0120] Users input the information needed for planning into the device, such as the project name, start date, end date, and major milestones, using a web browser or a dedicated application.

[0121] Input: Project name, start date, end date, milestone information

[0122] Output: Planning information entered into the terminal

[0123] Step 2:

[0124] The user device sends the entered information to the server, which converts the entered data into JSON format and sends it to the server via an HTTP request.

[0125] Input: Planning information entered into the terminal

[0126] Output: Plan information sent to the server (JSON format)

[0127] Step 3:

[0128] The server uses a generative AI model to generate a detailed plan based on the information it receives. The received data includes the project name, start date, end date, and milestone information. Based on this information, the generative AI model automatically generates each phase and task of the project.

[0129] Input: Plan information sent to the server (JSON format)

[0130] Output: Generated detailed planning data

[0131] Step 4:

[0132] The server analyzes the generated plan, using natural language processing techniques to detect ambiguous wording and unclear goals in the plan.

[0133] Input: Generated detailed planning data

[0134] Output: Information about detected ambiguous expressions and unclear targets

[0135] Step 5:

[0136] The server generates feedback based on the analysis results, such as suggestions for correcting ambiguous tasks or realizing unclear goals.

[0137] Input: Information about detected ambiguous expressions and unclear targets

[0138] Output: Specific feedback and suggestions for improvement

[0139] Step 6:

[0140] The server converts the improved planning data back into JSON format and sends it to the user's device.

[0141] Input: Specific feedback and improvement suggestions

[0142] Output: Improved planning data (JSON format)

[0143] Step 7:

[0144] The user checks the improved plan data on the device. The user reviews the final plan based on the returned data, confirms and modifies it. In this process, any unclear points are resolved and the plan is made concrete.

[0145] Input: Refined planning data (JSON format)

[0146] Output: Confirmed and revised final plan

[0147] The above are the specific processing steps in the program of this system.

[0148] (Application example 1)

[0149] 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."

[0150] Traditionally, work schedules at logistics centers have often been created manually, which is time-consuming and labor-intensive, making it difficult to create efficient plans. Furthermore, unclear goals and vague expressions are often mixed together, making it easy for problems to arise during the execution stage of the plan. There is a demand for a system that can solve these problems and automatically create and improve efficient, high-quality work schedules.

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

[0152] In this invention, the server includes a means for receiving user data and using a generative AI model to generate specific plans, a means for learning from past plan data to generate and improve plans, and a means for analyzing the generated plans to point out ambiguous expressions and unclear goals and provide suggestions for improvement, thereby enabling users to automatically create and improve efficient, high-quality work schedules.

[0153] "User terminal" means a device used by a user to input, confirm, or modify information necessary for planning, and includes computing devices such as smartphones, tablets, and personal computers.

[0154] "Data format" refers to the conversion of input information into a standardized digital format, including formats such as JSON and XML.

[0155] "Server" refers to a computer system that receives data sent from a user device and uses a generative AI model to generate, analyze, and refine plans.

[0156] A "generative AI model" refers to an artificial intelligence technology that automatically generates specific plans based on input information and makes improvements based on learning from past data.

[0157] "Analysis" refers to the process of detecting ambiguous expressions and unclear goals in the generated plans, identifying them, and improving them.

[0158] "Feedback" refers to information including improvement suggestions and suggestions generated based on the analysis results, including advice and guidelines provided to users.

[0159] A "standard format" refers to a data format that conforms to a specific protocol or standard, and is a format that maintains compatibility when exchanging or sharing data.

[0160] "Past planning data" refers to information data about plans that were previously created and executed, and serves as material for the generative AI model to learn from.

[0161] "Planning data" refers to data containing specific work schedules and steps created by a generative AI model based on information entered by the user.

[0162] This invention relates to a system that allows users to efficiently plan and improve work schedules at logistics centers. This system includes multiple means for inputting information required for planning from a user terminal, generating specific plans based on that information, and analyzing and further improving those plans.

[0163] System Overview

[0164] Users input basic information about their work schedule using their smartphone, tablet, PC, or other device. This information includes the task name, start date, end date, and key points for each task. This information is converted into a standardized data format (e.g., JSON) and sent to the server.

[0165] The server first receives the data sent by the user. The received data is analyzed by a generative AI model (e.g., GPT-4), which generates a specific work plan based on the user's input. This generative AI model learns from past planning data and creates a plan based on the factors that led to the success and failure of the plan.

[0166] The generated plan then moves to the analysis step. In this analysis process, vague expressions and unclear goals in the plan are identified, and specific improvement suggestions are generated. For example, feedback such as "The deadline for this task is vague. Please set a specific deadline" is generated.

[0167] Once the analysis and refinement is complete, the plan data is converted back into a standard format and sent back to the user's device, where the user can review the refined plan and make further corrections as needed.

[0168] Hardware / software used and data processing

[0169] Hardware used

[0170] "User devices" such as smartphones, tablets, and PCs

[0171] "Server" that generates plans and performs analysis

[0172] Software used

[0173] "Planning support app" on the user's device

[0174] Server-side "generative AI model" (e.g., GPT-4)

[0175] Data processing and calculation

[0176] 1. Transforming user input data

[0177] Convert the input plan information into JSON format

[0178] 2. Plan generation using generative AI models

[0179] Generate detailed plans based on JSON format data

[0180] 3. Plan Analysis

[0181] Identifying ambiguous language and unclear goals in generated plans

[0182] 4. Generate feedback

[0183] Generate improvement proposals

[0184] 5. Format conversion of improvement plan

[0185] Improved planning data reformatting

[0186] Specific examples

[0187] Let's imagine a scenario where a logistics center supervisor uses a smartphone to plan next week's inventory replenishment work. The following input prompts are used:

[0188] Prompt Sentence Examples

[0189] User input:

[0190] Project Name: "Warehouse Restock"

[0191] Start date: "2023-10-01"

[0192] End Date: "2023-10-10"

[0193] milestone:

[0194] Name: "Stock Arrival", Date: "2023-10-02"

[0195] Name: "Sorting", Date: "2023-10-03"

[0196] Based on this input, create a detailed, actionable and specific work plan.

[0197] In this way, the system supports the creation and improvement of efficient, high-quality plans, contributing to improved work efficiency at logistics centers.

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

[0199] Step 1:

[0200] Input from the user terminal

[0201] Users use their smartphone, tablet, PC, or other device to enter information necessary for planning, such as task name, start date, end date, and key points for each task. This input data is first entered in text format and then converted into a standard data format (e.g., JSON format) within the application. An example of input is a plan for inventory replenishment work. The user enters information such as "Project Name: Warehouse Restock," "Start Date: 2023-10-01," "End Date: 2023-10-10," and "Milestone: Stock Arrival 2023-10-02, Sorting 2023-10-03."

[0202] Step 2:

[0203] Data conversion and transmission

[0204] The user device converts the input information into JSON format and sends it to the server. This conversion process is performed using a standard library within the application (e.g., Python's json module). Specifically, the input text data is converted into a JSON object, and that data is sent to the server using an HTTP request. An example of converted data is {"project_name": "Warehouse Restock", "start_date": "2023-10-01", "end_date": "2023-10-10", "milestones": [{"name": "Stock Arrival", "date": "2023-10-02"}, {"name": "Sorting", "date": "2023-10-03"}]}.

[0205] Step 3:

[0206] Generate the plan

[0207] The server receives JSON data sent from the user's device. The server inputs this data into a generative AI model (e.g., GPT-4) to automatically generate a specific work plan. The generative AI model analyzes the factors that led to the success or failure of the plan based on the user's input data and past planning data, and generates a detailed plan. In this generation process, the received JSON data is converted into text format and used as a prompt. An example of a prompt sentence provided to the generative AI is, "User input items: Project name: Warehouse Restock, Start date: 2023-10-01, End date: 2023-10-10, Milestones: Stock Arrival 2023-10-02, Sorting 2023-10-03. Based on this input data, please create a detailed, feasible, and specific work plan."

[0208] Step 4:

[0209] Plan Analysis

[0210] The server receives the generated plan and then analyzes it. During this analysis, it uses natural language processing techniques to detect ambiguous expressions and unclear goals in the generated plan. For example, it generates feedback such as, "The deadline for this task is ambiguous. Please set a specific deadline." As a result of the analysis, ambiguous parts and unclear goals are identified and areas for improvement are extracted.

[0211] Step 5:

[0212] Generating feedback and suggesting improvements

[0213] The server generates feedback based on the analysis results and presents specific suggestions for improvement. The feedback clearly points out vague or unclear parts of the automatically generated plan and includes specific suggestions for improving them. For example, it may include a specific improvement suggestion such as, "The deadline for this task is vague. Please set a specific deadline."

[0214] Step 6:

[0215] Improvement plan format conversion

[0216] The improved plan and feedback are converted back into a standard format (e.g., JSON format). The server performs this conversion process and generates the improved plan data and feedback as a JSON object. This conversion process prepares the user device to receive the data again.

[0217] Step 7:

[0218] Return to user device

[0219] The server sends the improved plan data and feedback back to the user's device. This is done as an HTTP response, which is received by the user and displayed visually within the application. The user reviews the returned data and confirms the final plan. At this stage, the user can take the feedback and improvements into account and make further revisions as needed.

[0220] In this way, the entire system works in cooperation with the user terminal, server, and generative AI model to enable efficient planning and improvement of work plans at logistics centers.

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

[0222] This invention combines a planning support system that uses generative AI with an emotion engine. In addition to the information that users input for planning, it has the ability to acquire their emotional data and generate, analyze, and improve plans by taking that emotional information into account.

[0223] First, the user enters the information required for planning (e.g., project name, start date, and end date) from a user device such as a web browser or application. The entered information is collected and temporarily saved on the device, and the emotion engine collects the user's emotional data.

[0224] Emotional data is extracted from facial expression recognition, voice analysis, vital signs, etc., and is also sent from the device to the server. Specifically, facial expressions, tone of voice, and input speed when the user enters information are analyzed as emotional data.

[0225] The server receives the plan information and emotion data sent from the user's device. It uses an emotion engine to analyze the emotion data and optimize the plan information entered by the user. For example, if the user is feeling stressed, feedback to reduce that stress can be incorporated into the plan.

[0226] The server then activates a generation AI based on the received data. The generation AI automatically creates a specific plan based on the plan information and emotional data provided by the user. The plan generation process takes into account the user's stress level and motivation state based on the emotional data.

[0227] The server then calls an analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. It also takes into account emotional data and provides suggestions for improvement that are deemed optimal for the user. For example, it might suggest, "The deadline for this task is vague. Please set a specific deadline. Also, please schedule tasks so that you can take adequate breaks between tasks."

[0228] The improved plan data is converted back into JSON format and sent back to the user's device. The user can review the returned data and confirm it as the final plan. Feedback based on the emotional data is also displayed, allowing the user to make further revisions based on it.

[0229] As a concrete example, when a company's project manager creates a development plan for a new product, the user inputs information such as the product name, start date, end date, and major milestones from their device. At the same time, an emotion engine uses facial expression recognition and voice analysis to assess the project manager's stress level and motivation. The server receives this information and uses generative AI to create a detailed development schedule, further optimizing the plan by taking emotional data into account. For example, improvements can be made, such as adjusting the schedule to allow more rest time during periods of high stress.

[0230] In this way, the present invention supports even users who are not good at planning to easily create efficient, high-quality plans, and further improves the feasibility of plans and user satisfaction by taking into account the user's emotional state.

[0231] The processing flow will be explained below.

[0232] Step 1:

[0233] The user enters the information necessary for planning (e.g., project name, start date, and end date) into a web browser or application input form. The emotion engine installed on the user's device then analyzes the user's facial expression, tone of voice, input speed, and other factors in real time to collect emotional data.

[0234] Step 2:

[0235] The device detects that the user has clicked the "Submit" button on the input form. This triggers a process to convert the form data and emotion data into JSON format. The converted data is then sent to the server as a POST request using the HTTPS protocol.

[0236] Step 3:

[0237] The server receives the POST request sent from the device, extracts the JSON data from the request, and analyzes the plan information and emotion data.

[0238] Step 4:

[0239] The server analyzes the emotional data using an emotion engine to evaluate the user's emotional state (e.g., stress level, motivation), and optimizes the planning information based on the evaluation results.

[0240] Step 5:

[0241] The server launches a generation AI based on the received plan information. The generation AI automatically creates a specific plan using optimized user-provided data. Here, each phase and milestone of the project is specified in detail.

[0242] Step 6:

[0243] The server invokes an analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. It also takes into account emotional data to provide refinements that are deemed optimal for the user.

[0244] Step 7:

[0245] The server refines the plan based on the feedback from the analysis module. For example, if the user shows high stress, it will adjust the plan to allow for appropriate rest periods between tasks. This refined plan is then converted back into JSON format.

[0246] Step 8:

[0247] The refined planning data is sent back from the server to the device, securely using the HTTPS protocol.

[0248] Step 9:

[0249] The device parses the JSON data received from the server, converts the parsed data into a user-friendly format, and displays it in a web browser or application screen. The user can then review the improved plan and make further adjustments.

[0250] As a concrete example, when a company's project manager creates a development plan for a new product, the user inputs information such as the product name, start date, end date, and major milestones from their device. At the same time, an emotion engine collects emotional data through facial recognition and voice analysis to evaluate the project manager's stress level and motivation. The server receives this information and uses generative AI to create a detailed development schedule, further optimizing the plan by taking the emotional data into account. For example, improvements can be made, such as adjusting the schedule to allow more rest time during periods of high stress.

[0251] Example 2

[0252] 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."

[0253] Conventional planning systems generate uniform schedules without considering the user's emotional state, making it impossible to provide optimal plans that address the user's stress and motivation. Furthermore, they lack the ability to point out ambiguous expressions and unclear goals after the plan is generated, and provide feedback. This reduces the feasibility of the plan and makes it difficult to improve user satisfaction.

[0254] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for collecting information and emotional data input from a user terminal and transmitting them to the server, means for generating a plan based on the received information and emotional data, means for optimizing the plan based on the emotional data, and means for analyzing the generated plan to point out ambiguous expressions and unclear goals and returning the analyzed plan and feedback to the user terminal. This makes it possible to generate a plan that takes the user's emotional state into consideration, thereby improving the feasibility of the plan and user satisfaction.

[0255] A "user terminal" is a device containing hardware and software that allows a user to input information required for planning.

[0256] "Emotional data" refers to data that indicates the user's emotional state, extracted from facial expression recognition, voice analysis, vital signs, etc.

[0257] A "server" is a system including hardware and software for receiving information and emotion data sent from a user terminal and generating, optimizing, and analyzing plans.

[0258] "Information necessary for planning" refers to basic information for planning, such as the project name, start date, end date, and major milestones.

[0259] A "generative AI model" is an artificial intelligence model that automatically creates specific plans based on planning information and emotional data provided by the user.

[0260] "Optimization" is the process of adjusting plans based on emotional data, taking into account the user's stress level and motivation state.

[0261] "Analysis" is the process of detecting and pointing out ambiguous expressions and unclear goals in the generated plan.

[0262] "Feedback" refers to suggestions for improvement or points of advice provided to users based on the analysis results.

[0263] The JSON format is a lightweight data exchange format for storing and transmitting structured data.

[0264] This invention is a system that combines a planning support system using generative AI with an emotion engine. In addition to the information that users input for planning, it has the function of acquiring the user's emotional data and generating, analyzing, and improving plans by taking that emotional information into account.

[0265] First, the user enters the information required for planning (e.g., project name, start date, end date) from a user device such as a web browser or mobile application. Specifically, to create a plan, the user enters "Project name: New product development," "Start date: October 1, 2023," "End date: September 30, 2024," etc.

[0266] Next, the device collects the input plan information and uses an emotion engine to collect the user's emotional data. Emotional data is extracted from facial expression recognition (e.g., camera), voice analysis (e.g., microphone), and vital signs (e.g., wearable devices). For example, facial expressions, tone of voice, and input speed when the user enters information are analyzed as emotional data.

[0267] The collected planning information and emotion data is sent from the device to a server, where the data is encrypted using a security protocol (e.g., HTTPS).

[0268] The server analyzes the received emotion data using an emotion engine (e.g., IBM Watson Tone Analyzer) to evaluate the user's stress level and motivation. For example, if the user is feeling high stress, the server extracts the stress level as a numerical value.

[0269] The server then optimizes the plan information entered by the user based on the analysis results. For example, if the user is feeling stressed, the server will incorporate feedback to reduce that stress into the plan.

[0270] Next, the server launches a generative AI model (e.g., OpenAI GPT-4) to automatically create a specific plan based on the user-provided plan information and emotion data. An example of an input prompt for the generative AI model is as follows:

[0271] "Create a detailed plan for product development based on the following information:

[0272] Product name: New product development

[0273] Start date: October 1, 2023

[0274] End date: September 30, 2024

[0275] Key milestones: market research, design, prototyping, mass production

[0276] User stress levels are high. Please include adequate rest time in the plan and provide suggestions for reducing stress."

[0277] Furthermore, the server analyzes the generated plan using an analysis module (e.g., a natural language processing engine) to detect ambiguous expressions and unclear goals in the plan and generate feedback, such as "The deadline for this task is vague. Please set a specific deadline. Also, please adjust your schedule so that you can take adequate rest."

[0278] The improved plan data is converted back into JSON format and sent back to the user's device. The user can review the returned data and confirm it as the final plan. Feedback based on the emotional data is also displayed, allowing the user to make further revisions.

[0279] In this way, the present invention supports users who are not good at planning to easily create efficient, high-quality plans, and further improves the feasibility of plans and user satisfaction by taking into account the user's emotional state.

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

[0281] Step 1:

[0282] Users enter the information necessary for planning. Specifically, they use a web browser or mobile app to enter planning information such as "Project name: New product development," "Start date: October 1, 2023," and "End date: September 30, 2024" into a form. The entered information is temporarily saved on the device.

[0283] Input: Planning information such as project name, start date, and finish date

[0284] Output: Temporarily saved planning information

[0285] Step 2:

[0286] The device collects emotional data. While the user is entering information, the device's camera, microphone, wearable device, etc. are used to collect emotional data such as the user's facial expressions, voice tone, input speed, and heart rate in real time.

[0287] Input: Camera footage, audio data, vital signs

[0288] Output: Collected emotion data

[0289] Step 3:

[0290] The device converts the collected planning information and emotion data into JSON format and sends it to the server using a security protocol (HTTPS).

[0291] Input: Planning information, emotion data

[0292] Output: Data sent to the server (JSON format)

[0293] Step 4:

[0294] The server receives the transmitted data and analyzes the emotional data. Using an emotion engine (e.g., IBM Watson Tone Analyzer), it evaluates the user's stress level and motivation. The analysis results are quantified, and if the stress level is high, it is rated as "High."

[0295] Input: Emotion data

[0296] Output: Sentiment analysis result (e.g., stress level "High")

[0297] Step 5:

[0298] The server then optimizes the plan based on the analysis of the emotional data. For example, if the stress level is assessed as "High," the plan will be adjusted to include more rest time.

[0299] Input: Plan information, emotion analysis results

[0300] Output: Optimized planning information

[0301] Step 6:

[0302] The server uses a generative AI model (e.g., OpenAI GPT-4) to automatically create a detailed plan based on the optimized planning information and emotion data. The generative AI model uses the following input prompt:

[0303] "Create a detailed plan for product development based on the following information:

[0304] Product name: New product development

[0305] Start date: October 1, 2023

[0306] End date: September 30, 2024

[0307] Key milestones: market research, design, prototyping, mass production

[0308] User stress levels are high. Please include adequate rest time in the plan and provide suggestions for reducing stress."

[0309] Input: Optimized planning information, emotional data

[0310] Output: Generated detailed plan

[0311] Step 7:

[0312] The server analyzes the generated plan using an analysis module (e.g., a natural language processing engine) to detect ambiguous expressions and unclear goals in the plan, and generates feedback for the user based on that information.

[0313] Input: Generated plan

[0314] Output: Feedback (e.g., "The due date for this task is vague. Please set a more specific due date. Also, please adjust your schedule so that you can take adequate rest.")

[0315] Step 8:

[0316] The server adds feedback to the optimized planning data and returns it to the device in JSON format.

[0317] Input: Optimized planning information, feedback

[0318] Output: Reply data to the terminal (JSON format)

[0319] Step 9:

[0320] The user can review the returned plan data and make any necessary corrections. Feedback based on the emotional data is also displayed, allowing the user to further refine the plan.

[0321] Input: Returned planning data, feedback

[0322] Output: Revised final plan

[0323] (Application example 2)

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

[0325] Because the planning process does not take into account the user's emotional state, the resulting plans may cause excessive stress for the user. Furthermore, when plans have ambiguities or unclear goals, there is a lack of efficient ways to identify and improve them. This leads to problems such as reduced feasibility of plans and reduced user satisfaction, particularly in the case of staff shift management in brick-and-mortar stores.

[0326] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for inputting information necessary for plan creation from a user terminal, means for transmitting the input information to the server, means for generating a plan based on the information received by the server, means for analyzing the generated plan and pointing out ambiguous expressions and unclear goals, means for improving the analyzed plan and returning it to the user terminal, and means for collecting emotional data and reflecting the emotional data in plan generation. This makes it possible to generate an optimal plan that takes the user's emotional state into consideration, thereby improving the feasibility of the plan and user satisfaction.

[0327] A "user terminal" is a computing device used by a user to input planning information, typically a smartphone, tablet, or personal computer.

[0328] The "server" is a central processing unit that receives data sent from user terminals and performs plan generation and analysis.

[0329] "Information necessary for planning" refers to the specific data and conditions necessary to create a plan, such as staff names, desired work days, and store opening hours.

[0330] "Emotional data" refers to data about a user's emotional state extracted from facial expression recognition, voice analysis, vital signs, etc.

[0331] "Means for generating a plan" refers to algorithms or software for creating a specific plan based on the information and emotional data required for planning received by the server.

[0332] "Means for identifying ambiguous language and unclear goals" refers to algorithms and software that automatically detect unclear points or areas that need improvement in the generated plans and provide feedback to the user.

[0333] "Means for improving the analyzed plan" refers to processes and software for optimizing the plan based on the analysis results and revising it to make it feasible and satisfactory for the user.

[0334] "Generative AI" refers to artificial intelligence that uses machine learning techniques to automatically create new plans based on data provided by users.

[0335] "Means for collecting emotional data" refers to hardware or software that extracts a user's emotional state from facial expressions, tone of voice, typing speed, etc.

[0336] A "shift schedule" refers to a timetable that allocates staff working days and hours in a rational and efficient manner.

[0337] The present invention can be implemented as a staff shift management application for brick-and-mortar stores. This application uses smartphones and tablets to input information necessary for planning and collect emotional data. This data is then sent to a server, which analyzes the data and generates an optimal shift schedule.

[0338] Specifically, the store manager, who is the user, uses a smartphone or tablet to input information such as staff member names, desired work days, and store hours, and collects emotional data through the emotion engine. Emotion data is acquired using technologies such as facial recognition and voice analysis. For example, Microsoft Azure Cognitive Services or Google Cloud Vision AI can be used as the emotion engine.

[0339] The collected data is sent from the user's device to a server. The server then uses a generative AI model (e.g., OpenAI's GPT-4) to automatically generate an optimal shift schedule based on the received plan information and emotion data. The generated plan is then passed through an analysis module to identify ambiguous expressions and unclear goals, and any necessary refinements are made. This analysis and refinement process is carried out on a cloud server, such as an AWS EC2 instance.

[0340] The improved shift schedule is converted into JSON format and sent back to the user's device. The optimized schedule can be viewed and modified on the user's device. Feedback based on emotion data is also displayed, allowing the user to make further modifications.

[0341] As a concrete example, consider a scenario in which a store manager is planning staff shifts from October 1st to October 3rd. The manager enters data using prompt statements such as:

[0342] Example prompt sentence:

[0343] "Plan staff shifts from October 1, 2023 to October 3, 2023. Generate optimal shifts based on the staff information and sentiment data below.

[0344] Staff Information:

[0345] Staff A (Desired work date: October 1st)

[0346] Staff B (Desired work date: October 2nd)

[0347] Staff C (Desired work date: October 3rd)

[0348] Emotional Data:

[0349] Staff A: Low stress level, high motivation

[0350] Staff B: Medium stress level, low motivation

[0351] Staff C: High stress level, medium motivation

[0352] Store hours are 9:00 to 18:00. The shifts generated take into account stress levels and ensure staff are able to work efficiently.

[0353] In this way, the present invention is able to generate optimal shift schedules that take into account the user's emotional state, improving feasibility and user satisfaction.

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

[0355] Step 1:

[0356] The user uses a smartphone or tablet device to input the information necessary for planning. For example, the user inputs the staff member's name, desired work date, store business hours, etc. At this time, the device temporarily saves the input plan information. The input data is recorded in the form of, for example, Staff A (desired work date: October 1st), Staff B (desired work date: October 2nd), Staff C (desired work date: October 3rd), etc.

[0357] Step 2:

[0358] The device uses an emotion engine to collect emotional data. It obtains emotional information from the user's facial expression, voice analysis, vital signs, etc. For example, it uses Microsoft Azure Cognitive Services and Google Cloud Vision AI to evaluate the user's stress level and motivation. The collected emotional data is saved in the form of: Staff A: low stress level, high motivation; Staff B: medium stress level, low motivation; Staff C: high stress level, medium motivation; etc.

[0359] Step 3:

[0360] The device sends the input plan information and emotion data to the server. The data is converted to JSON format and sent to the server using a security protocol (e.g., HTTPS). The sent data includes each staff member's name, desired work date, stress level, and motivation level.

[0361] Step 4:

[0362] The server generates a plan based on the received plan information and emotional data. Specifically, it uses a generative AI model (such as OpenAI's GPT-4) to generate an optimal shift schedule. It integrates the plan from the input data and outputs a schedule that takes into account shift balance and efficiency. For example, if staff member A is available to work on other days, it selects days with less stress based on emotional data.

[0363] Step 5:

[0364] The server analyzes the plan and points out any ambiguity or unclear goals. Using the analysis module, it detects problems in the plan and automatically generates feedback. For example, it checks whether certain staff members' shifts are consecutive, or whether break times are set appropriately.

[0365] Step 6:

[0366] The server improves the plan based on the analysis results. Based on the feedback obtained from the analysis module, the plan is revised. Specifically, it performs operations such as rearranging shifts and inserting appropriate rest periods. The improved plan is converted back into JSON format.

[0367] Step 7:

[0368] The server sends the improved plan back to the user's device. The device displays the received data, and the user can check the optimized shift schedule. For example, the new schedule will be displayed on the device screen, with Staff A's work days changed to October 1st and October 3rd, Staff B's ​​work days changed to October 2nd and October 4th, etc.

[0369] Step 8:

[0370] The user reviews the displayed plan and makes any final adjustments, either on-device or manually, based on feedback generated from emotion data. Once complete, the final shift schedule is confirmed.

[0371] The above are the processing steps in a specific embodiment of the present invention.

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

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

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

[0375] [Second embodiment]

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

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

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

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

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

[0381] 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).

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

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

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

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

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

[0387] 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."

[0388] This invention relates to a planning support system that uses generative AI. This system allows users to input the information necessary for planning, generates a specific plan based on that information, and analyzes and further improves the generated plan.

[0389] First, the user enters the information required for planning (e.g., project name, start date, and end date) from a user device such as a web browser or application. The entered data is converted into a standard format such as JSON and sent to the server.

[0390] The server receives data sent from the user's device and first uses a generation AI to generate a specific plan. Based on the data provided by the user, the generation AI sets out detailed details for each phase and milestone of the project. This plan generation process takes into account not only the planning method for new projects, but also factors for success and failure learned from past planning data.

[0391] The server then analyzes the generated plan. During this analysis, it detects ambiguous expressions and unclear goals in the plan and generates feedback to improve them. For example, it may say, "The deadline for this task is vague. Please set a concrete deadline." It also provides suggestions for improvement. This analysis and refinement step increases the feasibility of the plan.

[0392] The improved plan data is then converted back into a standard format such as JSON and sent back to the user's device. The user can then review the returned data and confirm it as the final plan, enabling them to create efficient, high-quality plans.

[0393] A specific use case could be as follows: When a company's project manager creates a development plan for a new product, the user inputs basic information such as the product name, start date, end date, and major milestones from their device. The server receives this information and uses generative AI to create a detailed development schedule. The server then analyzes the generated plan, points out ambiguities and unclear goals, and provides specific suggestions for improvement. Finally, the improved plan is sent back to the user's device, and the project manager uses it to proceed with the project.

[0394] In this way, the present invention supports users who are not good at planning to easily create efficient, high-quality plans, thereby standardizing planning skills throughout the organization.

[0395] The processing flow will be explained below.

[0396] Step 1:

[0397] The user enters the information required for planning (e.g., project name, start date, end date) into a web browser or application input form. The entered information is temporarily stored in the device's memory.

[0398] Step 2:

[0399] The device detects that the user has clicked the "Submit" button on the input form. This triggers a process to convert the form data into JSON format. The converted data is then sent to the server as a POST request using the HTTPS protocol.

[0400] Step 3:

[0401] The server receives the POST request sent from the device. The server extracts the JSON data from the request, parses it, and starts the plan generation process based on the information provided by the user (project name, start date, end date, etc.).

[0402] Step 4:

[0403] The server then triggers a generative AI based on the received data, which then uses the user-provided data to automatically create a concrete plan, detailing each phase and milestone of the project.

[0404] Step 5:

[0405] The server calls the analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. For example, it might say, "The deadline for this task is vague. Please set a concrete deadline."

[0406] Step 6:

[0407] The server refines the plan based on the feedback from the analysis module, and the refined plan is converted back into JSON format.

[0408] Step 7:

[0409] The refined planning data is sent back from the server to the device, securely using the HTTPS protocol.

[0410] Step 8:

[0411] The device parses the JSON data received from the server, converts the parsed data into a user-friendly format, and displays it in a web browser or application screen. The user can then review the improved plan and make further adjustments if necessary.

[0412] This series of processes allows users to easily create efficient, high-quality plans and prepare them for execution.

[0413] Example 1

[0414] 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."

[0415] Conventional planning systems require users to manually create detailed plans and correct any ambiguities or unclear goals, which makes the process inefficient and time-consuming. Furthermore, the quality of the plans depends on the skills of the users, making it difficult to standardize them.

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

[0417] In this invention, the server includes a means for inputting information required for planning from a user terminal, a means for transmitting the input information to the server, a means for generating a specific plan using a generative AI model, a means for analyzing the generated plan and pointing out ambiguous expressions and unclear goals, and a means for improving the analyzed plan and returning it to the user terminal. This makes it possible to automate and streamline planning and standardize the quality of plans.

[0418] A "user terminal" is a computer device that allows a user to input information necessary for planning and communicate with the server.

[0419] "Means of input" refers to the methods and functions that allow users to input information required for planning into the system.

[0420] "Means for transmitting" refers to the method or function for transmitting information entered from a user terminal to a server.

[0421] "Server" is a central control device that receives information sent from user terminals and generates, analyzes, and improves plans.

[0422] A "generative AI model" is an algorithm or model that uses artificial intelligence to generate specific plans from user data.

[0423] "Means for generating specific plans" refers to methods and functions that utilize generative AI models to create detailed plans based on user-provided data.

[0424] "Means for pointing out ambiguous expressions and unclear goals" refers to a method or function for analyzing the contents of the generated plan and detecting and pointing out ambiguous or unclear parts.

[0425] "Means for improving and returning" refers to a method or function for improving the analyzed plan and transmitting the improved plan data to the user terminal.

[0426] "Means for learning from past planning data" refers to a method or function by which the server analyzes and learns from planning data generated in the past to improve the accuracy of planning.

[0427] "Means for providing feedback" refers to methods and functions for communicating to the user any problems or improvement suggestions detected based on the generated plan.

[0428] This invention relates to a planning support system that uses a generative AI model. Users input the information necessary for planning from their user terminal, and the server generates a specific plan based on that information, analyzes it, and returns the improved plan to the user terminal. This system realizes automation, efficiency, and high quality of planning.

[0429] System Overview

[0430] User Device

[0431] A user terminal is a computer device where a user inputs information required for planning and sends it to the server. The user uses a web browser or a dedicated application to input information such as the project name, start date, end date, and major milestones. For example, the user might input a prompt such as:

[0432] Example prompt sentence:

[0433] Project Name: New Product Development

[0434] Start date: 2023-11-01

[0435] End date: 2024-06-30

[0436] Major milestones:

[0437] Idea Planning: 2023-11-15

[0438] Prototype development: 2024-01-31

[0439] User test: 2024-03-15

[0440] Product launch: 2024-06-30

[0441] server

[0442] The server receives the data sent from the user device and generates a detailed plan using a generative AI model (e.g., OpenAI GPT-4). Specifically, the process proceeds as follows:

[0443] 1. Data Reception

[0444] The server receives the information sent from the user device and converts the data into a standard format such as JSON, including the project name, start date, end date, and milestone information.

[0445] 2. Plan Generation

[0446] The server uses a generative AI model to generate a specific plan based on the received data, taking into account the data provided by the user and past planning data to define each phase and milestone of the project in detail.

[0447] Specific plan generation examples:

[0448] Project "New Product Development":

[0449] Phase 1: Idea Planning (2023-11-01 ~ 2023-11-15)

[0450] Task 1: Idea Brainstorming (2023-11-02)

[0451] Task 2: Initial Investigation (2023-11-05)

[0452] Phase 2: Prototype Development (2023-11-16 ~ 2024-01-31)

[0453] Task 1: Prototype Design (2023-11-20)

[0454] Task 2: Initial prototype creation (2023-12-05)

[0455] 3. Plan analysis and feedback generation

[0456] The server analyzes the generated plan to detect ambiguous expressions and unclear goals, and generates feedback such as, "The end date for prototype development is unclear. Please specify the number of prototypes and the end conditions."

[0457] 4. Submit your feedback and improvement plan

[0458] The server sends the generated feedback back to the user's device, and the user can then modify the plan based on this feedback and finalize the plan.

[0459] To give a specific example, when a project manager at a company plans the development of a new product, he or she enters the following information from a user terminal:

[0460] Example prompt sentence:

[0461] Project Name: New Product Development

[0462] Start date: 2023-11-01

[0463] End date: 2024-06-30

[0464] Major milestones:

[0465] Idea Planning: 2023-11-15

[0466] Prototype development: 2024-01-31

[0467] User test: 2024-03-15

[0468] Product launch: 2024-06-30

[0469] The server receives this information and uses a generative AI model to create a detailed development schedule. It then analyzes the generated plan, points out ambiguities and unclear goals, and provides specific suggestions for improvement. Finally, the improved plan is returned to the user's device, and the project manager uses it to proceed with the project. In this way, the present invention helps even users who are not good at planning to easily create efficient, high-quality plans, thereby standardizing planning skills throughout the organization.

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

[0471] Step 1:

[0472] Users input the information needed for planning into the device, such as the project name, start date, end date, and major milestones, using a web browser or a dedicated application.

[0473] Input: Project name, start date, end date, milestone information

[0474] Output: Planning information entered into the terminal

[0475] Step 2:

[0476] The user device sends the entered information to the server, which converts the entered data into JSON format and sends it to the server via an HTTP request.

[0477] Input: Planning information entered into the terminal

[0478] Output: Plan information sent to the server (JSON format)

[0479] Step 3:

[0480] The server uses a generative AI model to generate a detailed plan based on the information it receives. The received data includes the project name, start date, end date, and milestone information. Based on this information, the generative AI model automatically generates each phase and task of the project.

[0481] Input: Plan information sent to the server (JSON format)

[0482] Output: Generated detailed planning data

[0483] Step 4:

[0484] The server analyzes the generated plan, using natural language processing techniques to detect ambiguous wording and unclear goals in the plan.

[0485] Input: Generated detailed planning data

[0486] Output: Information about detected ambiguous expressions and unclear targets

[0487] Step 5:

[0488] The server generates feedback based on the analysis results, such as suggestions for correcting ambiguous tasks or realizing unclear goals.

[0489] Input: Information about detected ambiguous expressions and unclear targets

[0490] Output: Specific feedback and suggestions for improvement

[0491] Step 6:

[0492] The server converts the improved planning data back into JSON format and sends it to the user's device.

[0493] Input: Specific feedback and improvement suggestions

[0494] Output: Improved planning data (JSON format)

[0495] Step 7:

[0496] The user checks the improved plan data on the device. The user reviews the final plan based on the returned data, confirms and modifies it. In this process, any unclear points are resolved and the plan is made concrete.

[0497] Input: Refined planning data (JSON format)

[0498] Output: Confirmed and revised final plan

[0499] The above are the specific processing steps in the program of this system.

[0500] (Application example 1)

[0501] 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."

[0502] Traditionally, work schedules at logistics centers have often been created manually, which is time-consuming and labor-intensive, making it difficult to create efficient plans. Furthermore, unclear goals and vague expressions are often mixed together, making it easy for problems to arise during the execution stage of the plan. There is a demand for a system that can solve these problems and automatically create and improve efficient, high-quality work schedules.

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

[0504] In this invention, the server includes a means for receiving user data and using a generative AI model to generate specific plans, a means for learning from past plan data to generate and improve plans, and a means for analyzing the generated plans to point out ambiguous expressions and unclear goals and provide suggestions for improvement, thereby enabling users to automatically create and improve efficient, high-quality work schedules.

[0505] "User terminal" means a device used by a user to input, confirm, or modify information necessary for planning, and includes computing devices such as smartphones, tablets, and personal computers.

[0506] "Data format" refers to the conversion of input information into a standardized digital format, including formats such as JSON and XML.

[0507] "Server" refers to a computer system that receives data sent from a user device and uses a generative AI model to generate, analyze, and refine plans.

[0508] A "generative AI model" refers to an artificial intelligence technology that automatically generates specific plans based on input information and makes improvements based on learning from past data.

[0509] "Analysis" refers to the process of detecting ambiguous expressions and unclear goals in the generated plans, identifying them, and improving them.

[0510] "Feedback" refers to information including improvement suggestions and suggestions generated based on the analysis results, including advice and guidelines provided to users.

[0511] A "standard format" refers to a data format that conforms to a specific protocol or standard, and is a format that maintains compatibility when exchanging or sharing data.

[0512] "Past planning data" refers to information data about plans that were previously created and executed, and serves as material for the generative AI model to learn from.

[0513] "Planning data" refers to data containing specific work schedules and steps created by a generative AI model based on information entered by the user.

[0514] This invention relates to a system that allows users to efficiently plan and improve work schedules at logistics centers. This system includes multiple means for inputting information required for planning from a user terminal, generating specific plans based on that information, and analyzing and further improving those plans.

[0515] System Overview

[0516] Users input basic information about their work schedule using their smartphone, tablet, PC, or other device. This information includes the task name, start date, end date, and key points for each task. This information is converted into a standardized data format (e.g., JSON) and sent to the server.

[0517] The server first receives the data sent by the user. The received data is analyzed by a generative AI model (e.g., GPT-4), which generates a specific work plan based on the user's input. This generative AI model learns from past planning data and creates a plan based on the factors that led to the success and failure of the plan.

[0518] The generated plan then moves to the analysis step. In this analysis process, vague expressions and unclear goals in the plan are identified, and specific improvement suggestions are generated. For example, feedback such as "The deadline for this task is vague. Please set a specific deadline" is generated.

[0519] Once the analysis and refinement is complete, the plan data is converted back into a standard format and sent back to the user's device, where the user can review the refined plan and make further corrections as needed.

[0520] Hardware / software used and data processing

[0521] Hardware used

[0522] "User devices" such as smartphones, tablets, and PCs

[0523] "Server" that generates plans and performs analysis

[0524] Software used

[0525] "Planning support app" on the user's device

[0526] Server-side "generative AI model" (e.g., GPT-4)

[0527] Data processing and calculation

[0528] 1. Transforming user input data

[0529] Convert the input plan information into JSON format

[0530] 2. Plan generation using generative AI models

[0531] Generate detailed plans based on JSON format data

[0532] 3. Plan Analysis

[0533] Identifying ambiguous language and unclear goals in generated plans

[0534] 4. Generate feedback

[0535] Generate improvement proposals

[0536] 5. Format conversion of improvement plan

[0537] Improved planning data reformatting

[0538] Specific examples

[0539] Let's imagine a scenario where a logistics center supervisor uses a smartphone to plan next week's inventory replenishment work. The following input prompts are used:

[0540] Prompt Sentence Examples

[0541] User input:

[0542] Project Name: "Warehouse Restock"

[0543] Start date: "2023-10-01"

[0544] End Date: "2023-10-10"

[0545] milestone:

[0546] Name: "Stock Arrival", Date: "2023-10-02"

[0547] Name: "Sorting", Date: "2023-10-03"

[0548] Based on this input, create a detailed, actionable and specific work plan.

[0549] In this way, the system supports the creation and improvement of efficient, high-quality plans, contributing to improved work efficiency at logistics centers.

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

[0551] Step 1:

[0552] Input from the user terminal

[0553] Users use their smartphone, tablet, PC, or other device to enter information necessary for planning, such as task name, start date, end date, and key points for each task. This input data is first entered in text format and then converted into a standard data format (e.g., JSON format) within the application. An example of input is a plan for inventory replenishment work. The user enters information such as "Project Name: Warehouse Restock," "Start Date: 2023-10-01," "End Date: 2023-10-10," and "Milestone: Stock Arrival 2023-10-02, Sorting 2023-10-03."

[0554] Step 2:

[0555] Data conversion and transmission

[0556] The user device converts the input information into JSON format and sends it to the server. This conversion process is performed using a standard library within the application (e.g., Python's json module). Specifically, the input text data is converted into a JSON object, and that data is sent to the server using an HTTP request. An example of converted data is {"project_name": "Warehouse Restock", "start_date": "2023-10-01", "end_date": "2023-10-10", "milestones": [{"name": "Stock Arrival", "date": "2023-10-02"}, {"name": "Sorting", "date": "2023-10-03"}]}.

[0557] Step 3:

[0558] Generate the plan

[0559] The server receives JSON data sent from the user's device. The server inputs this data into a generative AI model (e.g., GPT-4) to automatically generate a specific work plan. The generative AI model analyzes the factors that led to the success or failure of the plan based on the user's input data and past planning data, and generates a detailed plan. In this generation process, the received JSON data is converted into text format and used as a prompt. An example of a prompt sentence provided to the generative AI is, "User input items: Project name: Warehouse Restock, Start date: 2023-10-01, End date: 2023-10-10, Milestones: Stock Arrival 2023-10-02, Sorting 2023-10-03. Based on this input data, please create a detailed, feasible, and specific work plan."

[0560] Step 4:

[0561] Plan Analysis

[0562] The server receives the generated plan and then analyzes it. During this analysis, it uses natural language processing techniques to detect ambiguous expressions and unclear goals in the generated plan. For example, it generates feedback such as, "The deadline for this task is ambiguous. Please set a specific deadline." As a result of the analysis, ambiguous parts and unclear goals are identified and areas for improvement are extracted.

[0563] Step 5:

[0564] Generating feedback and suggesting improvements

[0565] The server generates feedback based on the analysis results and presents specific suggestions for improvement. The feedback clearly points out vague or unclear parts of the automatically generated plan and includes specific suggestions for improving them. For example, it may include a specific improvement suggestion such as, "The deadline for this task is vague. Please set a specific deadline."

[0566] Step 6:

[0567] Improvement plan format conversion

[0568] The improved plan and feedback are converted back into a standard format (e.g., JSON format). The server performs this conversion process and generates the improved plan data and feedback as a JSON object. This conversion process prepares the user device to receive the data again.

[0569] Step 7:

[0570] Return to user device

[0571] The server sends the improved plan data and feedback back to the user's device. This is done as an HTTP response, which is received by the user and displayed visually within the application. The user reviews the returned data and confirms the final plan. At this stage, the user can take the feedback and improvements into account and make further revisions as needed.

[0572] In this way, the entire system works in cooperation with the user terminal, server, and generative AI model to enable efficient planning and improvement of work plans at logistics centers.

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

[0574] This invention combines a planning support system that uses generative AI with an emotion engine. In addition to the information that users input for planning, it has the ability to acquire their emotional data and generate, analyze, and improve plans by taking that emotional information into account.

[0575] First, the user enters the information required for planning (e.g., project name, start date, and end date) from a user device such as a web browser or application. The entered information is collected and temporarily saved on the device, and the emotion engine collects the user's emotional data.

[0576] Emotional data is extracted from facial expression recognition, voice analysis, vital signs, etc., and is also sent from the device to the server. Specifically, facial expressions, tone of voice, and input speed when the user enters information are analyzed as emotional data.

[0577] The server receives the plan information and emotion data sent from the user's device. It uses an emotion engine to analyze the emotion data and optimize the plan information entered by the user. For example, if the user is feeling stressed, feedback to reduce that stress can be incorporated into the plan.

[0578] The server then activates a generation AI based on the received data. The generation AI automatically creates a specific plan based on the plan information and emotional data provided by the user. The plan generation process takes into account the user's stress level and motivation state based on the emotional data.

[0579] The server then calls an analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. It also takes into account emotional data and provides suggestions for improvement that are deemed optimal for the user. For example, it might suggest, "The deadline for this task is vague. Please set a specific deadline. Also, please schedule tasks so that you can take adequate breaks between tasks."

[0580] The improved plan data is converted back into JSON format and sent back to the user's device. The user can review the returned data and confirm it as the final plan. Feedback based on the emotional data is also displayed, allowing the user to make further revisions based on it.

[0581] As a concrete example, when a company's project manager creates a development plan for a new product, the user inputs information such as the product name, start date, end date, and major milestones from their device. At the same time, an emotion engine uses facial expression recognition and voice analysis to assess the project manager's stress level and motivation. The server receives this information and uses generative AI to create a detailed development schedule, further optimizing the plan by taking emotional data into account. For example, improvements can be made, such as adjusting the schedule to allow more rest time during periods of high stress.

[0582] In this way, the present invention supports even users who are not good at planning to easily create efficient, high-quality plans, and further improves the feasibility of plans and user satisfaction by taking into account the user's emotional state.

[0583] The processing flow will be explained below.

[0584] Step 1:

[0585] The user enters the information necessary for planning (e.g., project name, start date, and end date) into a web browser or application input form. The emotion engine installed on the user's device then analyzes the user's facial expression, tone of voice, input speed, and other factors in real time to collect emotional data.

[0586] Step 2:

[0587] The device detects that the user has clicked the "Submit" button on the input form. This triggers a process to convert the form data and emotion data into JSON format. The converted data is then sent to the server as a POST request using the HTTPS protocol.

[0588] Step 3:

[0589] The server receives the POST request sent from the device, extracts the JSON data from the request, and analyzes the plan information and emotion data.

[0590] Step 4:

[0591] The server analyzes the emotional data using an emotion engine to evaluate the user's emotional state (e.g., stress level, motivation), and optimizes the planning information based on the evaluation results.

[0592] Step 5:

[0593] The server launches a generation AI based on the received plan information. The generation AI automatically creates a specific plan using optimized user-provided data. Here, each phase and milestone of the project is specified in detail.

[0594] Step 6:

[0595] The server invokes an analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. It also takes into account emotional data to provide refinements that are deemed optimal for the user.

[0596] Step 7:

[0597] The server refines the plan based on the feedback from the analysis module. For example, if the user shows high stress, it will adjust the plan to allow for appropriate rest periods between tasks. This refined plan is then converted back into JSON format.

[0598] Step 8:

[0599] The refined planning data is sent back from the server to the device, securely using the HTTPS protocol.

[0600] Step 9:

[0601] The device parses the JSON data received from the server, converts the parsed data into a user-friendly format, and displays it in a web browser or application screen. The user can then review the improved plan and make further adjustments.

[0602] As a concrete example, when a company's project manager creates a development plan for a new product, the user inputs information such as the product name, start date, end date, and major milestones from their device. At the same time, an emotion engine collects emotional data through facial recognition and voice analysis to evaluate the project manager's stress level and motivation. The server receives this information and uses generative AI to create a detailed development schedule, further optimizing the plan by taking the emotional data into account. For example, improvements can be made, such as adjusting the schedule to allow more rest time during periods of high stress.

[0603] Example 2

[0604] 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."

[0605] Conventional planning systems generate uniform schedules without considering the user's emotional state, making it impossible to provide optimal plans that address the user's stress and motivation. Furthermore, they lack the ability to point out ambiguous expressions and unclear goals after the plan is generated, and provide feedback. This reduces the feasibility of the plan and makes it difficult to improve user satisfaction.

[0606] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for collecting information and emotional data input from a user terminal and transmitting them to the server, means for generating a plan based on the received information and emotional data, means for optimizing the plan based on the emotional data, and means for analyzing the generated plan to point out ambiguous expressions and unclear goals and returning the analyzed plan and feedback to the user terminal. This makes it possible to generate a plan that takes the user's emotional state into consideration, thereby improving the feasibility of the plan and user satisfaction.

[0607] A "user terminal" is a device containing hardware and software that allows a user to input information required for planning.

[0608] "Emotional data" refers to data that indicates the user's emotional state, extracted from facial expression recognition, voice analysis, vital signs, etc.

[0609] A "server" is a system including hardware and software for receiving information and emotion data sent from a user terminal and generating, optimizing, and analyzing plans.

[0610] "Information necessary for planning" refers to basic information for planning, such as the project name, start date, end date, and major milestones.

[0611] A "generative AI model" is an artificial intelligence model that automatically creates specific plans based on planning information and emotional data provided by the user.

[0612] "Optimization" is the process of adjusting plans based on emotional data, taking into account the user's stress level and motivation state.

[0613] "Analysis" is the process of detecting and pointing out ambiguous expressions and unclear goals in the generated plan.

[0614] "Feedback" refers to suggestions for improvement or points of advice provided to users based on the analysis results.

[0615] The JSON format is a lightweight data exchange format for storing and transmitting structured data.

[0616] This invention is a system that combines a planning support system using generative AI with an emotion engine. In addition to the information that users input for planning, it has the function of acquiring the user's emotional data and generating, analyzing, and improving plans by taking that emotional information into account.

[0617] First, the user enters the information required for planning (e.g., project name, start date, end date) from a user device such as a web browser or mobile application. Specifically, to create a plan, the user enters "Project name: New product development," "Start date: October 1, 2023," "End date: September 30, 2024," etc.

[0618] Next, the device collects the input plan information and uses an emotion engine to collect the user's emotional data. Emotional data is extracted from facial expression recognition (e.g., camera), voice analysis (e.g., microphone), and vital signs (e.g., wearable devices). For example, facial expressions, tone of voice, and input speed when the user enters information are analyzed as emotional data.

[0619] The collected planning information and emotion data is sent from the device to a server, where the data is encrypted using a security protocol (e.g., HTTPS).

[0620] The server analyzes the received emotion data using an emotion engine (e.g., IBM Watson Tone Analyzer) to evaluate the user's stress level and motivation. For example, if the user is feeling high stress, the server extracts the stress level as a numerical value.

[0621] The server then optimizes the plan information entered by the user based on the analysis results. For example, if the user is feeling stressed, the server will incorporate feedback to reduce that stress into the plan.

[0622] Next, the server launches a generative AI model (e.g., OpenAI GPT-4) to automatically create a specific plan based on the user-provided plan information and emotion data. An example of an input prompt for the generative AI model is as follows:

[0623] "Create a detailed plan for product development based on the following information:

[0624] Product name: New product development

[0625] Start date: October 1, 2023

[0626] End date: September 30, 2024

[0627] Key milestones: market research, design, prototyping, mass production

[0628] User stress levels are high. Please include adequate rest time in the plan and provide suggestions for reducing stress."

[0629] Furthermore, the server analyzes the generated plan using an analysis module (e.g., a natural language processing engine) to detect ambiguous expressions and unclear goals in the plan and generate feedback, such as "The deadline for this task is vague. Please set a specific deadline. Also, please adjust your schedule so that you can take adequate rest."

[0630] The improved plan data is converted back into JSON format and sent back to the user's device. The user can review the returned data and confirm it as the final plan. Feedback based on the emotional data is also displayed, allowing the user to make further revisions.

[0631] In this way, the present invention supports users who are not good at planning to easily create efficient, high-quality plans, and further improves the feasibility of plans and user satisfaction by taking into account the user's emotional state.

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

[0633] Step 1:

[0634] Users enter the information necessary for planning. Specifically, they use a web browser or mobile app to enter planning information such as "Project name: New product development," "Start date: October 1, 2023," and "End date: September 30, 2024" into a form. The entered information is temporarily saved on the device.

[0635] Input: Planning information such as project name, start date, and finish date

[0636] Output: Temporarily saved planning information

[0637] Step 2:

[0638] The device collects emotional data. While the user is entering information, the device's camera, microphone, wearable device, etc. are used to collect emotional data such as the user's facial expressions, voice tone, input speed, and heart rate in real time.

[0639] Input: Camera footage, audio data, vital signs

[0640] Output: Collected emotion data

[0641] Step 3:

[0642] The device converts the collected planning information and emotion data into JSON format and sends it to the server using a security protocol (HTTPS).

[0643] Input: Planning information, emotion data

[0644] Output: Data sent to the server (JSON format)

[0645] Step 4:

[0646] The server receives the transmitted data and analyzes the emotional data. Using an emotion engine (e.g., IBM Watson Tone Analyzer), it evaluates the user's stress level and motivation. The analysis results are quantified, and if the stress level is high, it is rated as "High."

[0647] Input: Emotion data

[0648] Output: Sentiment analysis result (e.g., stress level "High")

[0649] Step 5:

[0650] The server then optimizes the plan based on the analysis of the emotional data. For example, if the stress level is assessed as "High," the plan will be adjusted to include more rest time.

[0651] Input: Plan information, emotion analysis results

[0652] Output: Optimized planning information

[0653] Step 6:

[0654] The server uses a generative AI model (e.g., OpenAI GPT-4) to automatically create a detailed plan based on the optimized planning information and emotion data. The generative AI model uses the following input prompt:

[0655] "Create a detailed plan for product development based on the following information:

[0656] Product name: New product development

[0657] Start date: October 1, 2023

[0658] End date: September 30, 2024

[0659] Key milestones: market research, design, prototyping, mass production

[0660] User stress levels are high. Please include adequate rest time in the plan and provide suggestions for reducing stress."

[0661] Input: Optimized planning information, emotional data

[0662] Output: Generated detailed plan

[0663] Step 7:

[0664] The server analyzes the generated plan using an analysis module (e.g., a natural language processing engine) to detect ambiguous expressions and unclear goals in the plan, and generates feedback for the user based on that information.

[0665] Input: Generated plan

[0666] Output: Feedback (e.g., "The due date for this task is vague. Please set a more specific due date. Also, please adjust your schedule so that you can take adequate rest.")

[0667] Step 8:

[0668] The server adds feedback to the optimized planning data and returns it to the device in JSON format.

[0669] Input: Optimized planning information, feedback

[0670] Output: Reply data to the terminal (JSON format)

[0671] Step 9:

[0672] The user can review the returned plan data and make any necessary corrections. Feedback based on the emotional data is also displayed, allowing the user to further refine the plan.

[0673] Input: Returned planning data, feedback

[0674] Output: Revised final plan

[0675] (Application example 2)

[0676] 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."

[0677] Because the planning process does not take into account the user's emotional state, the resulting plans may cause excessive stress for the user. Furthermore, when plans have ambiguities or unclear goals, there is a lack of efficient ways to identify and improve them. This leads to problems such as reduced feasibility of plans and reduced user satisfaction, particularly in the case of staff shift management in brick-and-mortar stores.

[0678] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for inputting information necessary for plan creation from a user terminal, means for transmitting the input information to the server, means for generating a plan based on the information received by the server, means for analyzing the generated plan and pointing out ambiguous expressions and unclear goals, means for improving the analyzed plan and returning it to the user terminal, and means for collecting emotional data and reflecting the emotional data in plan generation. This makes it possible to generate an optimal plan that takes the user's emotional state into consideration, thereby improving the feasibility of the plan and user satisfaction.

[0679] A "user terminal" is a computing device used by a user to input planning information, typically a smartphone, tablet, or personal computer.

[0680] The "server" is a central processing unit that receives data sent from user terminals and performs plan generation and analysis.

[0681] "Information necessary for planning" refers to the specific data and conditions necessary to create a plan, such as staff names, desired work days, and store opening hours.

[0682] "Emotional data" refers to data about a user's emotional state extracted from facial expression recognition, voice analysis, vital signs, etc.

[0683] "Means for generating a plan" refers to algorithms or software for creating a specific plan based on the information and emotional data required for planning received by the server.

[0684] "Means for identifying ambiguous language and unclear goals" refers to algorithms and software that automatically detect unclear points or areas that need improvement in the generated plans and provide feedback to the user.

[0685] "Means for improving the analyzed plan" refers to processes and software for optimizing the plan based on the analysis results and revising it to make it feasible and satisfactory for the user.

[0686] "Generative AI" refers to artificial intelligence that uses machine learning techniques to automatically create new plans based on data provided by users.

[0687] "Means for collecting emotional data" refers to hardware or software that extracts a user's emotional state from facial expressions, tone of voice, typing speed, etc.

[0688] A "shift schedule" refers to a timetable that allocates staff working days and hours in a rational and efficient manner.

[0689] The present invention can be implemented as a staff shift management application for brick-and-mortar stores. This application uses smartphones and tablets to input information necessary for planning and collect emotional data. This data is then sent to a server, which analyzes the data and generates an optimal shift schedule.

[0690] Specifically, the store manager, who is the user, uses a smartphone or tablet to input information such as staff member names, desired work days, and store hours, and collects emotional data through the emotion engine. Emotion data is acquired using technologies such as facial recognition and voice analysis. For example, Microsoft Azure Cognitive Services or Google Cloud Vision AI can be used as the emotion engine.

[0691] The collected data is sent from the user's device to a server. The server then uses a generative AI model (e.g., OpenAI's GPT-4) to automatically generate an optimal shift schedule based on the received plan information and emotion data. The generated plan is then passed through an analysis module to identify ambiguous expressions and unclear goals, and any necessary refinements are made. This analysis and refinement process is carried out on a cloud server, such as an AWS EC2 instance.

[0692] The improved shift schedule is converted into JSON format and sent back to the user's device. The optimized schedule can be viewed and modified on the user's device. Feedback based on emotion data is also displayed, allowing the user to make further modifications.

[0693] As a concrete example, consider a scenario in which a store manager is planning staff shifts from October 1st to October 3rd. The manager enters data using prompt statements such as:

[0694] Example prompt sentence:

[0695] "Plan staff shifts from October 1, 2023 to October 3, 2023. Generate optimal shifts based on the staff information and sentiment data below.

[0696] Staff Information:

[0697] Staff A (Desired work date: October 1st)

[0698] Staff B (Desired work date: October 2nd)

[0699] Staff C (Desired work date: October 3rd)

[0700] Emotional Data:

[0701] Staff A: Low stress level, high motivation

[0702] Staff B: Medium stress level, low motivation

[0703] Staff C: High stress level, medium motivation

[0704] Store hours are 9:00 to 18:00. The shifts generated take into account stress levels and ensure staff are able to work efficiently.

[0705] In this way, the present invention is able to generate optimal shift schedules that take into account the user's emotional state, improving feasibility and user satisfaction.

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

[0707] Step 1:

[0708] The user uses a smartphone or tablet device to input the information necessary for planning. For example, the user inputs the staff member's name, desired work date, store business hours, etc. At this time, the device temporarily saves the input plan information. The input data is recorded in the form of, for example, Staff A (desired work date: October 1st), Staff B (desired work date: October 2nd), Staff C (desired work date: October 3rd), etc.

[0709] Step 2:

[0710] The device uses an emotion engine to collect emotional data. It obtains emotional information from the user's facial expression, voice analysis, vital signs, etc. For example, it uses Microsoft Azure Cognitive Services and Google Cloud Vision AI to evaluate the user's stress level and motivation. The collected emotional data is saved in the form of: Staff A: low stress level, high motivation; Staff B: medium stress level, low motivation; Staff C: high stress level, medium motivation; etc.

[0711] Step 3:

[0712] The device sends the input plan information and emotion data to the server. The data is converted to JSON format and sent to the server using a security protocol (e.g., HTTPS). The sent data includes each staff member's name, desired work date, stress level, and motivation level.

[0713] Step 4:

[0714] The server generates a plan based on the received plan information and emotional data. Specifically, it uses a generative AI model (such as OpenAI's GPT-4) to generate an optimal shift schedule. It integrates the plan from the input data and outputs a schedule that takes into account shift balance and efficiency. For example, if staff member A is available to work on other days, it selects days with less stress based on emotional data.

[0715] Step 5:

[0716] The server analyzes the plan and points out any ambiguity or unclear goals. Using the analysis module, it detects problems in the plan and automatically generates feedback. For example, it checks whether certain staff members' shifts are consecutive, or whether break times are set appropriately.

[0717] Step 6:

[0718] The server improves the plan based on the analysis results. Based on the feedback obtained from the analysis module, the plan is revised. Specifically, it performs operations such as rearranging shifts and inserting appropriate rest periods. The improved plan is converted back into JSON format.

[0719] Step 7:

[0720] The server sends the improved plan back to the user's device. The device displays the received data, and the user can check the optimized shift schedule. For example, the new schedule will be displayed on the device screen, with Staff A's work days changed to October 1st and October 3rd, Staff B's ​​work days changed to October 2nd and October 4th, etc.

[0721] Step 8:

[0722] The user reviews the displayed plan and makes any final adjustments, either on-device or manually, based on feedback generated from emotion data. Once complete, the final shift schedule is confirmed.

[0723] The above are the processing steps in a specific embodiment of the present invention.

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

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

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

[0727] [Third embodiment]

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

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

[0730] 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).

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

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

[0733] 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).

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

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

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

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

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

[0739] 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."

[0740] This invention relates to a planning support system that uses generative AI. This system allows users to input the information necessary for planning, generates a specific plan based on that information, and analyzes and further improves the generated plan.

[0741] First, the user enters the information required for planning (e.g., project name, start date, and end date) from a user device such as a web browser or application. The entered data is converted into a standard format such as JSON and sent to the server.

[0742] The server receives data sent from the user's device and first uses a generation AI to generate a specific plan. Based on the data provided by the user, the generation AI sets out detailed details for each phase and milestone of the project. This plan generation process takes into account not only the planning method for new projects, but also factors for success and failure learned from past planning data.

[0743] The server then analyzes the generated plan. During this analysis, it detects ambiguous expressions and unclear goals in the plan and generates feedback to improve them. For example, it may say, "The deadline for this task is vague. Please set a concrete deadline." It also provides suggestions for improvement. This analysis and refinement step increases the feasibility of the plan.

[0744] The improved plan data is then converted back into a standard format such as JSON and sent back to the user's device. The user can then review the returned data and confirm it as the final plan, enabling them to create efficient, high-quality plans.

[0745] A specific use case could be as follows: When a company's project manager creates a development plan for a new product, the user inputs basic information such as the product name, start date, end date, and major milestones from their device. The server receives this information and uses generative AI to create a detailed development schedule. The server then analyzes the generated plan, points out ambiguities and unclear goals, and provides specific suggestions for improvement. Finally, the improved plan is sent back to the user's device, and the project manager uses it to proceed with the project.

[0746] In this way, the present invention supports users who are not good at planning to easily create efficient, high-quality plans, thereby standardizing planning skills throughout the organization.

[0747] The processing flow will be explained below.

[0748] Step 1:

[0749] The user enters the information required for planning (e.g., project name, start date, end date) into a web browser or application input form. The entered information is temporarily stored in the device's memory.

[0750] Step 2:

[0751] The device detects that the user has clicked the "Submit" button on the input form. This triggers a process to convert the form data into JSON format. The converted data is then sent to the server as a POST request using the HTTPS protocol.

[0752] Step 3:

[0753] The server receives the POST request sent from the device. The server extracts the JSON data from the request, parses it, and starts the plan generation process based on the information provided by the user (project name, start date, end date, etc.).

[0754] Step 4:

[0755] The server then triggers a generative AI based on the received data, which then uses the user-provided data to automatically create a concrete plan, detailing each phase and milestone of the project.

[0756] Step 5:

[0757] The server calls the analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. For example, it might say, "The deadline for this task is vague. Please set a concrete deadline."

[0758] Step 6:

[0759] The server refines the plan based on the feedback from the analysis module, and the refined plan is converted back into JSON format.

[0760] Step 7:

[0761] The refined planning data is sent back from the server to the device, securely using the HTTPS protocol.

[0762] Step 8:

[0763] The device parses the JSON data received from the server, converts the parsed data into a user-friendly format, and displays it in a web browser or application screen. The user can then review the improved plan and make further adjustments if necessary.

[0764] This series of processes allows users to easily create efficient, high-quality plans and prepare them for execution.

[0765] Example 1

[0766] 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."

[0767] Conventional planning systems require users to manually create detailed plans and correct any ambiguities or unclear goals, which makes the process inefficient and time-consuming. Furthermore, the quality of the plans depends on the skills of the users, making it difficult to standardize them.

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

[0769] In this invention, the server includes a means for inputting information required for planning from a user terminal, a means for transmitting the input information to the server, a means for generating a specific plan using a generative AI model, a means for analyzing the generated plan and pointing out ambiguous expressions and unclear goals, and a means for improving the analyzed plan and returning it to the user terminal. This makes it possible to automate and streamline planning and standardize the quality of plans.

[0770] A "user terminal" is a computer device that allows a user to input information necessary for planning and communicate with the server.

[0771] "Means of input" refers to the methods and functions that allow users to input information required for planning into the system.

[0772] "Means for transmitting" refers to the method or function for transmitting information entered from a user terminal to a server.

[0773] "Server" is a central control device that receives information sent from user terminals and generates, analyzes, and improves plans.

[0774] A "generative AI model" is an algorithm or model that uses artificial intelligence to generate specific plans from user data.

[0775] "Means for generating specific plans" refers to methods and functions that utilize generative AI models to create detailed plans based on user-provided data.

[0776] "Means for pointing out ambiguous expressions and unclear goals" refers to a method or function for analyzing the contents of the generated plan and detecting and pointing out ambiguous or unclear parts.

[0777] "Means for improving and returning" refers to a method or function for improving the analyzed plan and transmitting the improved plan data to the user terminal.

[0778] "Means for learning from past planning data" refers to a method or function by which the server analyzes and learns from planning data generated in the past to improve the accuracy of planning.

[0779] "Means for providing feedback" refers to methods and functions for communicating to the user any problems or improvement suggestions detected based on the generated plan.

[0780] This invention relates to a planning support system that uses a generative AI model. Users input the information necessary for planning from their user terminal, and the server generates a specific plan based on that information, analyzes it, and returns the improved plan to the user terminal. This system realizes automation, efficiency, and high quality of planning.

[0781] System Overview

[0782] User Device

[0783] A user terminal is a computer device where a user inputs information required for planning and sends it to the server. The user uses a web browser or a dedicated application to input information such as the project name, start date, end date, and major milestones. For example, the user might input a prompt such as:

[0784] Example prompt sentence:

[0785] Project Name: New Product Development

[0786] Start date: 2023-11-01

[0787] End date: 2024-06-30

[0788] Major milestones:

[0789] Idea Planning: 2023-11-15

[0790] Prototype development: 2024-01-31

[0791] User test: 2024-03-15

[0792] Product launch: 2024-06-30

[0793] server

[0794] The server receives the data sent from the user device and generates a detailed plan using a generative AI model (e.g., OpenAI GPT-4). Specifically, the process proceeds as follows:

[0795] 1. Data Reception

[0796] The server receives the information sent from the user device and converts the data into a standard format such as JSON, including the project name, start date, end date, and milestone information.

[0797] 2. Plan Generation

[0798] The server uses a generative AI model to generate a specific plan based on the received data, taking into account the data provided by the user and past planning data to define each phase and milestone of the project in detail.

[0799] Specific plan generation examples:

[0800] Project "New Product Development":

[0801] Phase 1: Idea Planning (2023-11-01 ~ 2023-11-15)

[0802] Task 1: Idea Brainstorming (2023-11-02)

[0803] Task 2: Initial Investigation (2023-11-05)

[0804] Phase 2: Prototype Development (2023-11-16 ~ 2024-01-31)

[0805] Task 1: Prototype Design (2023-11-20)

[0806] Task 2: Initial prototype creation (2023-12-05)

[0807] 3. Plan analysis and feedback generation

[0808] The server analyzes the generated plan to detect ambiguous expressions and unclear goals, and generates feedback such as, "The end date for prototype development is unclear. Please specify the number of prototypes and the end conditions."

[0809] 4. Submit your feedback and improvement plan

[0810] The server sends the generated feedback back to the user's device, and the user can then modify the plan based on this feedback and finalize the plan.

[0811] To give a specific example, when a project manager at a company plans the development of a new product, he or she enters the following information from a user terminal:

[0812] Example prompt sentence:

[0813] Project Name: New Product Development

[0814] Start date: 2023-11-01

[0815] End date: 2024-06-30

[0816] Major milestones:

[0817] Idea Planning: 2023-11-15

[0818] Prototype development: 2024-01-31

[0819] User test: 2024-03-15

[0820] Product launch: 2024-06-30

[0821] The server receives this information and uses a generative AI model to create a detailed development schedule. It then analyzes the generated plan, points out ambiguities and unclear goals, and provides specific suggestions for improvement. Finally, the improved plan is returned to the user's device, and the project manager uses it to proceed with the project. In this way, the present invention helps even users who are not good at planning to easily create efficient, high-quality plans, thereby standardizing planning skills throughout the organization.

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

[0823] Step 1:

[0824] Users input the information needed for planning into the device, such as the project name, start date, end date, and major milestones, using a web browser or a dedicated application.

[0825] Input: Project name, start date, end date, milestone information

[0826] Output: Planning information entered into the terminal

[0827] Step 2:

[0828] The user device sends the entered information to the server, which converts the entered data into JSON format and sends it to the server via an HTTP request.

[0829] Input: Planning information entered into the terminal

[0830] Output: Plan information sent to the server (JSON format)

[0831] Step 3:

[0832] The server uses a generative AI model to generate a detailed plan based on the information it receives. The received data includes the project name, start date, end date, and milestone information. Based on this information, the generative AI model automatically generates each phase and task of the project.

[0833] Input: Plan information sent to the server (JSON format)

[0834] Output: Generated detailed planning data

[0835] Step 4:

[0836] The server analyzes the generated plan, using natural language processing techniques to detect ambiguous wording and unclear goals in the plan.

[0837] Input: Generated detailed planning data

[0838] Output: Information about detected ambiguous expressions and unclear targets

[0839] Step 5:

[0840] The server generates feedback based on the analysis results, such as suggestions for correcting ambiguous tasks or realizing unclear goals.

[0841] Input: Information about detected ambiguous expressions and unclear targets

[0842] Output: Specific feedback and suggestions for improvement

[0843] Step 6:

[0844] The server converts the improved planning data back into JSON format and sends it to the user's device.

[0845] Input: Specific feedback and improvement suggestions

[0846] Output: Improved planning data (JSON format)

[0847] Step 7:

[0848] The user checks the improved plan data on the device. The user reviews the final plan based on the returned data, confirms and modifies it. In this process, any unclear points are resolved and the plan is made concrete.

[0849] Input: Refined planning data (JSON format)

[0850] Output: Confirmed and revised final plan

[0851] The above are the specific processing steps in the program of this system.

[0852] (Application example 1)

[0853] 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."

[0854] Traditionally, work schedules at logistics centers have often been created manually, which is time-consuming and labor-intensive, making it difficult to create efficient plans. Furthermore, unclear goals and vague expressions are often mixed together, making it easy for problems to arise during the execution stage of the plan. There is a demand for a system that can solve these problems and automatically create and improve efficient, high-quality work schedules.

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

[0856] In this invention, the server includes a means for receiving user data and using a generative AI model to generate specific plans, a means for learning from past plan data to generate and improve plans, and a means for analyzing the generated plans to point out ambiguous expressions and unclear goals and provide suggestions for improvement, thereby enabling users to automatically create and improve efficient, high-quality work schedules.

[0857] "User terminal" means a device used by a user to input, confirm, or modify information necessary for planning, and includes computing devices such as smartphones, tablets, and personal computers.

[0858] "Data format" refers to the conversion of input information into a standardized digital format, including formats such as JSON and XML.

[0859] "Server" refers to a computer system that receives data sent from a user device and uses a generative AI model to generate, analyze, and refine plans.

[0860] A "generative AI model" refers to an artificial intelligence technology that automatically generates specific plans based on input information and makes improvements based on learning from past data.

[0861] "Analysis" refers to the process of detecting ambiguous expressions and unclear goals in the generated plans, identifying them, and improving them.

[0862] "Feedback" refers to information including improvement suggestions and suggestions generated based on the analysis results, including advice and guidelines provided to users.

[0863] A "standard format" refers to a data format that conforms to a specific protocol or standard, and is a format that maintains compatibility when exchanging or sharing data.

[0864] "Past planning data" refers to information data about plans that were previously created and executed, and serves as material for the generative AI model to learn from.

[0865] "Planning data" refers to data containing specific work schedules and steps created by a generative AI model based on information entered by the user.

[0866] This invention relates to a system that allows users to efficiently plan and improve work schedules at logistics centers. This system includes multiple means for inputting information required for planning from a user terminal, generating specific plans based on that information, and analyzing and further improving those plans.

[0867] System Overview

[0868] Users input basic information about their work schedule using their smartphone, tablet, PC, or other device. This information includes the task name, start date, end date, and key points for each task. This information is converted into a standardized data format (e.g., JSON) and sent to the server.

[0869] The server first receives the data sent by the user. The received data is analyzed by a generative AI model (e.g., GPT-4), which generates a specific work plan based on the user's input. This generative AI model learns from past planning data and creates a plan based on the factors that led to the success and failure of the plan.

[0870] The generated plan then moves to the analysis step. In this analysis process, vague expressions and unclear goals in the plan are identified, and specific improvement suggestions are generated. For example, feedback such as "The deadline for this task is vague. Please set a specific deadline" is generated.

[0871] Once the analysis and refinement is complete, the plan data is converted back into a standard format and sent back to the user's device, where the user can review the refined plan and make further corrections as needed.

[0872] Hardware / software used and data processing

[0873] Hardware used

[0874] "User devices" such as smartphones, tablets, and PCs

[0875] "Server" that generates plans and performs analysis

[0876] Software used

[0877] "Planning support app" on the user's device

[0878] Server-side "generative AI model" (e.g., GPT-4)

[0879] Data processing and calculation

[0880] 1. Transforming user input data

[0881] Convert the input plan information into JSON format

[0882] 2. Plan generation using generative AI models

[0883] Generate detailed plans based on JSON format data

[0884] 3. Plan Analysis

[0885] Identifying ambiguous language and unclear goals in generated plans

[0886] 4. Generate feedback

[0887] Generate improvement proposals

[0888] 5. Format conversion of improvement plan

[0889] Improved planning data reformatting

[0890] Specific examples

[0891] Let's imagine a scenario where a logistics center supervisor uses a smartphone to plan next week's inventory replenishment work. The following input prompts are used:

[0892] Prompt Sentence Examples

[0893] User input:

[0894] Project Name: "Warehouse Restock"

[0895] Start date: "2023-10-01"

[0896] End Date: "2023-10-10"

[0897] milestone:

[0898] Name: "Stock Arrival", Date: "2023-10-02"

[0899] Name: "Sorting", Date: "2023-10-03"

[0900] Based on this input, create a detailed, actionable and specific work plan.

[0901] In this way, the system supports the creation and improvement of efficient, high-quality plans, contributing to improved work efficiency at logistics centers.

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

[0903] Step 1:

[0904] Input from the user terminal

[0905] Users use their smartphone, tablet, PC, or other device to enter information necessary for planning, such as task name, start date, end date, and key points for each task. This input data is first entered in text format and then converted into a standard data format (e.g., JSON format) within the application. An example of input is a plan for inventory replenishment work. The user enters information such as "Project Name: Warehouse Restock," "Start Date: 2023-10-01," "End Date: 2023-10-10," and "Milestone: Stock Arrival 2023-10-02, Sorting 2023-10-03."

[0906] Step 2:

[0907] Data conversion and transmission

[0908] The user device converts the input information into JSON format and sends it to the server. This conversion process is performed using a standard library within the application (e.g., Python's json module). Specifically, the input text data is converted into a JSON object, and that data is sent to the server using an HTTP request. An example of converted data is {"project_name": "Warehouse Restock", "start_date": "2023-10-01", "end_date": "2023-10-10", "milestones": [{"name": "Stock Arrival", "date": "2023-10-02"}, {"name": "Sorting", "date": "2023-10-03"}]}.

[0909] Step 3:

[0910] Generate the plan

[0911] The server receives JSON data sent from the user's device. The server inputs this data into a generative AI model (e.g., GPT-4) to automatically generate a specific work plan. The generative AI model analyzes the factors that led to the success or failure of the plan based on the user's input data and past planning data, and generates a detailed plan. In this generation process, the received JSON data is converted into text format and used as a prompt. An example of a prompt sentence provided to the generative AI is, "User input items: Project name: Warehouse Restock, Start date: 2023-10-01, End date: 2023-10-10, Milestones: Stock Arrival 2023-10-02, Sorting 2023-10-03. Based on this input data, please create a detailed, feasible, and specific work plan."

[0912] Step 4:

[0913] Plan Analysis

[0914] The server receives the generated plan and then analyzes it. During this analysis, it uses natural language processing techniques to detect ambiguous expressions and unclear goals in the generated plan. For example, it generates feedback such as, "The deadline for this task is ambiguous. Please set a specific deadline." As a result of the analysis, ambiguous parts and unclear goals are identified and areas for improvement are extracted.

[0915] Step 5:

[0916] Generating feedback and suggesting improvements

[0917] The server generates feedback based on the analysis results and presents specific suggestions for improvement. The feedback clearly points out vague or unclear parts of the automatically generated plan and includes specific suggestions for improving them. For example, it may include a specific improvement suggestion such as, "The deadline for this task is vague. Please set a specific deadline."

[0918] Step 6:

[0919] Improvement plan format conversion

[0920] The improved plan and feedback are converted back into a standard format (e.g., JSON format). The server performs this conversion process and generates the improved plan data and feedback as a JSON object. This conversion process prepares the user device to receive the data again.

[0921] Step 7:

[0922] Return to user device

[0923] The server sends the improved plan data and feedback back to the user's device. This is done as an HTTP response, which is received by the user and displayed visually within the application. The user reviews the returned data and confirms the final plan. At this stage, the user can take the feedback and improvements into account and make further revisions as needed.

[0924] In this way, the entire system works in cooperation with the user terminal, server, and generative AI model to enable efficient planning and improvement of work plans at logistics centers.

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

[0926] This invention combines a planning support system that uses generative AI with an emotion engine. In addition to the information that users input for planning, it has the ability to acquire their emotional data and generate, analyze, and improve plans by taking that emotional information into account.

[0927] First, the user enters the information required for planning (e.g., project name, start date, and end date) from a user device such as a web browser or application. The entered information is collected and temporarily saved on the device, and the emotion engine collects the user's emotional data.

[0928] Emotional data is extracted from facial expression recognition, voice analysis, vital signs, etc., and is also sent from the device to the server. Specifically, facial expressions, tone of voice, and input speed when the user enters information are analyzed as emotional data.

[0929] The server receives the plan information and emotion data sent from the user's device. It uses an emotion engine to analyze the emotion data and optimize the plan information entered by the user. For example, if the user is feeling stressed, feedback to reduce that stress can be incorporated into the plan.

[0930] The server then activates a generation AI based on the received data. The generation AI automatically creates a specific plan based on the plan information and emotional data provided by the user. The plan generation process takes into account the user's stress level and motivation state based on the emotional data.

[0931] The server then calls an analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. It also takes into account emotional data and provides suggestions for improvement that are deemed optimal for the user. For example, it might suggest, "The deadline for this task is vague. Please set a specific deadline. Also, please schedule tasks so that you can take adequate breaks between tasks."

[0932] The improved plan data is converted back into JSON format and sent back to the user's device. The user can review the returned data and confirm it as the final plan. Feedback based on the emotional data is also displayed, allowing the user to make further revisions based on it.

[0933] As a concrete example, when a company's project manager creates a development plan for a new product, the user inputs information such as the product name, start date, end date, and major milestones from their device. At the same time, an emotion engine uses facial expression recognition and voice analysis to assess the project manager's stress level and motivation. The server receives this information and uses generative AI to create a detailed development schedule, further optimizing the plan by taking emotional data into account. For example, improvements can be made, such as adjusting the schedule to allow more rest time during periods of high stress.

[0934] In this way, the present invention supports even users who are not good at planning to easily create efficient, high-quality plans, and further improves the feasibility of plans and user satisfaction by taking into account the user's emotional state.

[0935] The processing flow will be explained below.

[0936] Step 1:

[0937] The user enters the information necessary for planning (e.g., project name, start date, and end date) into a web browser or application input form. The emotion engine installed on the user's device then analyzes the user's facial expression, tone of voice, input speed, and other factors in real time to collect emotional data.

[0938] Step 2:

[0939] The device detects that the user has clicked the "Submit" button on the input form. This triggers a process to convert the form data and emotion data into JSON format. The converted data is then sent to the server as a POST request using the HTTPS protocol.

[0940] Step 3:

[0941] The server receives the POST request sent from the device, extracts the JSON data from the request, and analyzes the plan information and emotion data.

[0942] Step 4:

[0943] The server analyzes the emotional data using an emotion engine to evaluate the user's emotional state (e.g., stress level, motivation), and optimizes the planning information based on the evaluation results.

[0944] Step 5:

[0945] The server launches a generation AI based on the received plan information. The generation AI automatically creates a specific plan using optimized user-provided data. Here, each phase and milestone of the project is specified in detail.

[0946] Step 6:

[0947] The server invokes an analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. It also takes into account emotional data to provide refinements that are deemed optimal for the user.

[0948] Step 7:

[0949] The server refines the plan based on the feedback from the analysis module. For example, if the user shows high stress, it will adjust the plan to allow for appropriate rest periods between tasks. This refined plan is then converted back into JSON format.

[0950] Step 8:

[0951] The refined planning data is sent back from the server to the device, securely using the HTTPS protocol.

[0952] Step 9:

[0953] The device parses the JSON data received from the server, converts the parsed data into a user-friendly format, and displays it in a web browser or application screen. The user can then review the improved plan and make further adjustments.

[0954] As a concrete example, when a company's project manager creates a development plan for a new product, the user inputs information such as the product name, start date, end date, and major milestones from their device. At the same time, an emotion engine collects emotional data through facial recognition and voice analysis to evaluate the project manager's stress level and motivation. The server receives this information and uses generative AI to create a detailed development schedule, further optimizing the plan by taking the emotional data into account. For example, improvements can be made, such as adjusting the schedule to allow more rest time during periods of high stress.

[0955] Example 2

[0956] 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."

[0957] Conventional planning systems generate uniform schedules without considering the user's emotional state, making it impossible to provide optimal plans that address the user's stress and motivation. Furthermore, they lack the ability to point out ambiguous expressions and unclear goals after the plan is generated, and provide feedback. This reduces the feasibility of the plan and makes it difficult to improve user satisfaction.

[0958] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for collecting information and emotional data input from a user terminal and transmitting them to the server, means for generating a plan based on the received information and emotional data, means for optimizing the plan based on the emotional data, and means for analyzing the generated plan to point out ambiguous expressions and unclear goals and returning the analyzed plan and feedback to the user terminal. This makes it possible to generate a plan that takes the user's emotional state into consideration, thereby improving the feasibility of the plan and user satisfaction.

[0959] A "user terminal" is a device containing hardware and software that allows a user to input information required for planning.

[0960] "Emotional data" refers to data that indicates the user's emotional state, extracted from facial expression recognition, voice analysis, vital signs, etc.

[0961] A "server" is a system including hardware and software for receiving information and emotion data sent from a user terminal and generating, optimizing, and analyzing plans.

[0962] "Information necessary for planning" refers to basic information for planning, such as the project name, start date, end date, and major milestones.

[0963] A "generative AI model" is an artificial intelligence model that automatically creates specific plans based on planning information and emotional data provided by the user.

[0964] "Optimization" is the process of adjusting plans based on emotional data, taking into account the user's stress level and motivation state.

[0965] "Analysis" is the process of detecting and pointing out ambiguous expressions and unclear goals in the generated plan.

[0966] "Feedback" refers to suggestions for improvement or points of advice provided to users based on the analysis results.

[0967] The JSON format is a lightweight data exchange format for storing and transmitting structured data.

[0968] This invention is a system that combines a planning support system using generative AI with an emotion engine. In addition to the information that users input for planning, it has the function of acquiring the user's emotional data and generating, analyzing, and improving plans by taking that emotional information into account.

[0969] First, the user enters the information required for planning (e.g., project name, start date, end date) from a user device such as a web browser or mobile application. Specifically, to create a plan, the user enters "Project name: New product development," "Start date: October 1, 2023," "End date: September 30, 2024," etc.

[0970] Next, the device collects the input plan information and uses an emotion engine to collect the user's emotional data. Emotional data is extracted from facial expression recognition (e.g., camera), voice analysis (e.g., microphone), and vital signs (e.g., wearable devices). For example, facial expressions, tone of voice, and input speed when the user enters information are analyzed as emotional data.

[0971] The collected planning information and emotion data is sent from the device to a server, where the data is encrypted using a security protocol (e.g., HTTPS).

[0972] The server analyzes the received emotion data using an emotion engine (e.g., IBM Watson Tone Analyzer) to evaluate the user's stress level and motivation. For example, if the user is feeling high stress, the server extracts the stress level as a numerical value.

[0973] The server then optimizes the plan information entered by the user based on the analysis results. For example, if the user is feeling stressed, the server will incorporate feedback to reduce that stress into the plan.

[0974] Next, the server launches a generative AI model (e.g., OpenAI GPT-4) to automatically create a specific plan based on the user-provided plan information and emotion data. An example of an input prompt for the generative AI model is as follows:

[0975] "Create a detailed plan for product development based on the following information:

[0976] Product name: New product development

[0977] Start date: October 1, 2023

[0978] End date: September 30, 2024

[0979] Key milestones: market research, design, prototyping, mass production

[0980] User stress levels are high. Please include adequate rest time in the plan and provide suggestions for reducing stress."

[0981] Furthermore, the server analyzes the generated plan using an analysis module (e.g., a natural language processing engine) to detect ambiguous expressions and unclear goals in the plan and generate feedback, such as "The deadline for this task is vague. Please set a specific deadline. Also, please adjust your schedule so that you can take adequate rest."

[0982] The improved plan data is converted back into JSON format and sent back to the user's device. The user can review the returned data and confirm it as the final plan. Feedback based on the emotional data is also displayed, allowing the user to make further revisions.

[0983] In this way, the present invention supports users who are not good at planning to easily create efficient, high-quality plans, and further improves the feasibility of plans and user satisfaction by taking into account the user's emotional state.

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

[0985] Step 1:

[0986] Users enter the information necessary for planning. Specifically, they use a web browser or mobile app to enter planning information such as "Project name: New product development," "Start date: October 1, 2023," and "End date: September 30, 2024" into a form. The entered information is temporarily saved on the device.

[0987] Input: Planning information such as project name, start date, and finish date

[0988] Output: Temporarily saved planning information

[0989] Step 2:

[0990] The device collects emotional data. While the user is entering information, the device's camera, microphone, wearable device, etc. are used to collect emotional data such as the user's facial expressions, voice tone, input speed, and heart rate in real time.

[0991] Input: Camera footage, audio data, vital signs

[0992] Output: Collected emotion data

[0993] Step 3:

[0994] The device converts the collected planning information and emotion data into JSON format and sends it to the server using a security protocol (HTTPS).

[0995] Input: Planning information, emotion data

[0996] Output: Data sent to the server (JSON format)

[0997] Step 4:

[0998] The server receives the transmitted data and analyzes the emotional data. Using an emotion engine (e.g., IBM Watson Tone Analyzer), it evaluates the user's stress level and motivation. The analysis results are quantified, and if the stress level is high, it is rated as "High."

[0999] Input: Emotion data

[1000] Output: Sentiment analysis result (e.g., stress level "High")

[1001] Step 5:

[1002] The server then optimizes the plan based on the analysis of the emotional data. For example, if the stress level is assessed as "High," the plan will be adjusted to include more rest time.

[1003] Input: Plan information, emotion analysis results

[1004] Output: Optimized planning information

[1005] Step 6:

[1006] The server uses a generative AI model (e.g., OpenAI GPT-4) to automatically create a detailed plan based on the optimized planning information and emotion data. The generative AI model uses the following input prompt:

[1007] "Create a detailed plan for product development based on the following information:

[1008] Product name: New product development

[1009] Start date: October 1, 2023

[1010] End date: September 30, 2024

[1011] Key milestones: market research, design, prototyping, mass production

[1012] User stress levels are high. Please include adequate rest time in the plan and provide suggestions for reducing stress."

[1013] Input: Optimized planning information, emotional data

[1014] Output: Generated detailed plan

[1015] Step 7:

[1016] The server analyzes the generated plan using an analysis module (e.g., a natural language processing engine) to detect ambiguous expressions and unclear goals in the plan, and generates feedback for the user based on that information.

[1017] Input: Generated plan

[1018] Output: Feedback (e.g., "The due date for this task is vague. Please set a more specific due date. Also, please adjust your schedule so that you can take adequate rest.")

[1019] Step 8:

[1020] The server adds feedback to the optimized planning data and returns it to the device in JSON format.

[1021] Input: Optimized planning information, feedback

[1022] Output: Reply data to the terminal (JSON format)

[1023] Step 9:

[1024] The user can review the returned plan data and make any necessary corrections. Feedback based on the emotional data is also displayed, allowing the user to further refine the plan.

[1025] Input: Returned planning data, feedback

[1026] Output: Revised final plan

[1027] (Application example 2)

[1028] 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."

[1029] Because the planning process does not take into account the user's emotional state, the resulting plans may cause excessive stress for the user. Furthermore, when plans have ambiguities or unclear goals, there is a lack of efficient ways to identify and improve them. This leads to problems such as reduced feasibility of plans and reduced user satisfaction, particularly in the case of staff shift management in brick-and-mortar stores.

[1030] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for inputting information necessary for plan creation from a user terminal, means for transmitting the input information to the server, means for generating a plan based on the information received by the server, means for analyzing the generated plan and pointing out ambiguous expressions and unclear goals, means for improving the analyzed plan and returning it to the user terminal, and means for collecting emotional data and reflecting the emotional data in plan generation. This makes it possible to generate an optimal plan that takes the user's emotional state into consideration, thereby improving the feasibility of the plan and user satisfaction.

[1031] A "user terminal" is a computing device used by a user to input planning information, typically a smartphone, tablet, or personal computer.

[1032] The "server" is a central processing unit that receives data sent from user terminals and performs plan generation and analysis.

[1033] "Information necessary for planning" refers to the specific data and conditions necessary to create a plan, such as staff names, desired work days, and store opening hours.

[1034] "Emotional data" refers to data about a user's emotional state extracted from facial expression recognition, voice analysis, vital signs, etc.

[1035] "Means for generating a plan" refers to algorithms or software for creating a specific plan based on the information and emotional data required for planning received by the server.

[1036] "Means for identifying ambiguous language and unclear goals" refers to algorithms and software that automatically detect unclear points or areas that need improvement in the generated plans and provide feedback to the user.

[1037] "Means for improving the analyzed plan" refers to processes and software for optimizing the plan based on the analysis results and revising it to make it feasible and satisfactory for the user.

[1038] "Generative AI" refers to artificial intelligence that uses machine learning techniques to automatically create new plans based on data provided by users.

[1039] "Means for collecting emotional data" refers to hardware or software that extracts a user's emotional state from facial expressions, tone of voice, typing speed, etc.

[1040] A "shift schedule" refers to a timetable that allocates staff working days and hours in a rational and efficient manner.

[1041] The present invention can be implemented as a staff shift management application for brick-and-mortar stores. This application uses smartphones and tablets to input information necessary for planning and collect emotional data. This data is then sent to a server, which analyzes the data and generates an optimal shift schedule.

[1042] Specifically, the store manager, who is the user, uses a smartphone or tablet to input information such as staff member names, desired work days, and store hours, and collects emotional data through the emotion engine. Emotion data is acquired using technologies such as facial recognition and voice analysis. For example, Microsoft Azure Cognitive Services or Google Cloud Vision AI can be used as the emotion engine.

[1043] The collected data is sent from the user's device to a server. The server then uses a generative AI model (e.g., OpenAI's GPT-4) to automatically generate an optimal shift schedule based on the received plan information and emotion data. The generated plan is then passed through an analysis module to identify ambiguous expressions and unclear goals, and any necessary refinements are made. This analysis and refinement process is carried out on a cloud server, such as an AWS EC2 instance.

[1044] The improved shift schedule is converted into JSON format and sent back to the user's device. The optimized schedule can be viewed and modified on the user's device. Feedback based on emotion data is also displayed, allowing the user to make further modifications.

[1045] As a concrete example, consider a scenario in which a store manager is planning staff shifts from October 1st to October 3rd. The manager enters data using prompt statements such as:

[1046] Example prompt sentence:

[1047] "Plan staff shifts from October 1, 2023 to October 3, 2023. Generate optimal shifts based on the staff information and sentiment data below.

[1048] Staff Information:

[1049] Staff A (Desired work date: October 1st)

[1050] Staff B (Desired work date: October 2nd)

[1051] Staff C (Desired work date: October 3rd)

[1052] Emotional Data:

[1053] Staff A: Low stress level, high motivation

[1054] Staff B: Medium stress level, low motivation

[1055] Staff C: High stress level, medium motivation

[1056] Store hours are 9:00 to 18:00. The shifts generated take into account stress levels and ensure staff are able to work efficiently.

[1057] In this way, the present invention is able to generate optimal shift schedules that take into account the user's emotional state, improving feasibility and user satisfaction.

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

[1059] Step 1:

[1060] The user uses a smartphone or tablet device to input the information necessary for planning. For example, the user inputs the staff member's name, desired work date, store business hours, etc. At this time, the device temporarily saves the input plan information. The input data is recorded in the form of, for example, Staff A (desired work date: October 1st), Staff B (desired work date: October 2nd), Staff C (desired work date: October 3rd), etc.

[1061] Step 2:

[1062] The device uses an emotion engine to collect emotional data. It obtains emotional information from the user's facial expression, voice analysis, vital signs, etc. For example, it uses Microsoft Azure Cognitive Services and Google Cloud Vision AI to evaluate the user's stress level and motivation. The collected emotional data is saved in the form of: Staff A: low stress level, high motivation; Staff B: medium stress level, low motivation; Staff C: high stress level, medium motivation; etc.

[1063] Step 3:

[1064] The device sends the input plan information and emotion data to the server. The data is converted to JSON format and sent to the server using a security protocol (e.g., HTTPS). The sent data includes each staff member's name, desired work date, stress level, and motivation level.

[1065] Step 4:

[1066] The server generates a plan based on the received plan information and emotional data. Specifically, it uses a generative AI model (such as OpenAI's GPT-4) to generate an optimal shift schedule. It integrates the plan from the input data and outputs a schedule that takes into account shift balance and efficiency. For example, if staff member A is available to work on other days, it selects days with less stress based on emotional data.

[1067] Step 5:

[1068] The server analyzes the plan and points out any ambiguity or unclear goals. Using the analysis module, it detects problems in the plan and automatically generates feedback. For example, it checks whether certain staff members' shifts are consecutive, or whether break times are set appropriately.

[1069] Step 6:

[1070] The server improves the plan based on the analysis results. Based on the feedback obtained from the analysis module, the plan is revised. Specifically, it performs operations such as rearranging shifts and inserting appropriate rest periods. The improved plan is converted back into JSON format.

[1071] Step 7:

[1072] The server sends the improved plan back to the user's device. The device displays the received data, and the user can check the optimized shift schedule. For example, the new schedule will be displayed on the device screen, with Staff A's work days changed to October 1st and October 3rd, Staff B's ​​work days changed to October 2nd and October 4th, etc.

[1073] Step 8:

[1074] The user reviews the displayed plan and makes any final adjustments, either on-device or manually, based on feedback generated from emotion data. Once complete, the final shift schedule is confirmed.

[1075] The above are the processing steps in a specific embodiment of the present invention.

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

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

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

[1079] [Fourth embodiment]

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

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

[1082] 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).

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

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

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

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

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

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

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

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

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

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

[1093] This invention relates to a planning support system that uses generative AI. This system allows users to input the information necessary for planning, generates a specific plan based on that information, and analyzes and further improves the generated plan.

[1094] First, the user enters the information required for planning (e.g., project name, start date, and end date) from a user device such as a web browser or application. The entered data is converted into a standard format such as JSON and sent to the server.

[1095] The server receives data sent from the user's device and first uses a generation AI to generate a specific plan. Based on the data provided by the user, the generation AI sets out detailed details for each phase and milestone of the project. This plan generation process takes into account not only the planning method for new projects, but also factors for success and failure learned from past planning data.

[1096] The server then analyzes the generated plan. During this analysis, it detects ambiguous expressions and unclear goals in the plan and generates feedback to improve them. For example, it may say, "The deadline for this task is vague. Please set a concrete deadline." It also provides suggestions for improvement. This analysis and refinement step increases the feasibility of the plan.

[1097] The improved plan data is then converted back into a standard format such as JSON and sent back to the user's device. The user can then review the returned data and confirm it as the final plan, enabling them to create efficient, high-quality plans.

[1098] A specific use case could be as follows: When a company's project manager creates a development plan for a new product, the user inputs basic information such as the product name, start date, end date, and major milestones from their device. The server receives this information and uses generative AI to create a detailed development schedule. The server then analyzes the generated plan, points out ambiguities and unclear goals, and provides specific suggestions for improvement. Finally, the improved plan is sent back to the user's device, and the project manager uses it to proceed with the project.

[1099] In this way, the present invention supports users who are not good at planning to easily create efficient, high-quality plans, thereby standardizing planning skills throughout the organization.

[1100] The processing flow will be explained below.

[1101] Step 1:

[1102] The user enters the information required for planning (e.g., project name, start date, end date) into a web browser or application input form. The entered information is temporarily stored in the device's memory.

[1103] Step 2:

[1104] The device detects that the user has clicked the "Submit" button on the input form. This triggers a process to convert the form data into JSON format. The converted data is then sent to the server as a POST request using the HTTPS protocol.

[1105] Step 3:

[1106] The server receives the POST request sent from the device. The server extracts the JSON data from the request, parses it, and starts the plan generation process based on the information provided by the user (project name, start date, end date, etc.).

[1107] Step 4:

[1108] The server then triggers a generative AI based on the received data, which then uses the user-provided data to automatically create a concrete plan, detailing each phase and milestone of the project.

[1109] Step 5:

[1110] The server calls the analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. For example, it might say, "The deadline for this task is vague. Please set a concrete deadline."

[1111] Step 6:

[1112] The server refines the plan based on the feedback from the analysis module, and the refined plan is converted back into JSON format.

[1113] Step 7:

[1114] The refined planning data is sent back from the server to the device, securely using the HTTPS protocol.

[1115] Step 8:

[1116] The device parses the JSON data received from the server, converts the parsed data into a user-friendly format, and displays it in a web browser or application screen. The user can then review the improved plan and make further adjustments if necessary.

[1117] This series of processes allows users to easily create efficient, high-quality plans and prepare them for execution.

[1118] Example 1

[1119] 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."

[1120] Conventional planning systems require users to manually create detailed plans and correct any ambiguities or unclear goals, which makes the process inefficient and time-consuming. Furthermore, the quality of the plans depends on the skills of the users, making it difficult to standardize them.

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

[1122] In this invention, the server includes a means for inputting information required for planning from a user terminal, a means for transmitting the input information to the server, a means for generating a specific plan using a generative AI model, a means for analyzing the generated plan and pointing out ambiguous expressions and unclear goals, and a means for improving the analyzed plan and returning it to the user terminal. This makes it possible to automate and streamline planning and standardize the quality of plans.

[1123] A "user terminal" is a computer device that allows a user to input information necessary for planning and communicate with the server.

[1124] "Means of input" refers to the methods and functions that allow users to input information required for planning into the system.

[1125] "Means for transmitting" refers to the method or function for transmitting information entered from a user terminal to a server.

[1126] "Server" is a central control device that receives information sent from user terminals and generates, analyzes, and improves plans.

[1127] A "generative AI model" is an algorithm or model that uses artificial intelligence to generate specific plans from user data.

[1128] "Means for generating specific plans" refers to methods and functions that utilize generative AI models to create detailed plans based on user-provided data.

[1129] "Means for pointing out ambiguous expressions and unclear goals" refers to a method or function for analyzing the contents of the generated plan and detecting and pointing out ambiguous or unclear parts.

[1130] "Means for improving and returning" refers to a method or function for improving the analyzed plan and transmitting the improved plan data to the user terminal.

[1131] "Means for learning from past planning data" refers to a method or function by which the server analyzes and learns from planning data generated in the past to improve the accuracy of planning.

[1132] "Means for providing feedback" refers to methods and functions for communicating to the user any problems or improvement suggestions detected based on the generated plan.

[1133] This invention relates to a planning support system that uses a generative AI model. Users input the information necessary for planning from their user terminal, and the server generates a specific plan based on that information, analyzes it, and returns the improved plan to the user terminal. This system realizes automation, efficiency, and high quality of planning.

[1134] System Overview

[1135] User Device

[1136] A user terminal is a computer device where a user inputs information required for planning and sends it to the server. The user uses a web browser or a dedicated application to input information such as the project name, start date, end date, and major milestones. For example, the user might input a prompt such as:

[1137] Example prompt sentence:

[1138] Project Name: New Product Development

[1139] Start date: 2023-11-01

[1140] End date: 2024-06-30

[1141] Major milestones:

[1142] Idea Planning: 2023-11-15

[1143] Prototype development: 2024-01-31

[1144] User test: 2024-03-15

[1145] Product launch: 2024-06-30

[1146] server

[1147] The server receives the data sent from the user device and generates a detailed plan using a generative AI model (e.g., OpenAI GPT-4). Specifically, the process proceeds as follows:

[1148] 1. Data Reception

[1149] The server receives the information sent from the user device and converts the data into a standard format such as JSON, including the project name, start date, end date, and milestone information.

[1150] 2. Plan Generation

[1151] The server uses a generative AI model to generate a specific plan based on the received data, taking into account the data provided by the user and past planning data to define each phase and milestone of the project in detail.

[1152] Specific plan generation examples:

[1153] Project "New Product Development":

[1154] Phase 1: Idea Planning (2023-11-01 ~ 2023-11-15)

[1155] Task 1: Idea Brainstorming (2023-11-02)

[1156] Task 2: Initial Investigation (2023-11-05)

[1157] Phase 2: Prototype Development (2023-11-16 ~ 2024-01-31)

[1158] Task 1: Prototype Design (2023-11-20)

[1159] Task 2: Initial prototype creation (2023-12-05)

[1160] 3. Plan analysis and feedback generation

[1161] The server analyzes the generated plan to detect ambiguous expressions and unclear goals, and generates feedback such as, "The end date for prototype development is unclear. Please specify the number of prototypes and the end conditions."

[1162] 4. Submit your feedback and improvement plan

[1163] The server sends the generated feedback back to the user's device, and the user can then modify the plan based on this feedback and finalize the plan.

[1164] To give a specific example, when a project manager at a company plans the development of a new product, he or she enters the following information from a user terminal:

[1165] Example prompt sentence:

[1166] Project Name: New Product Development

[1167] Start date: 2023-11-01

[1168] End date: 2024-06-30

[1169] Major milestones:

[1170] Idea Planning: 2023-11-15

[1171] Prototype development: 2024-01-31

[1172] User test: 2024-03-15

[1173] Product launch: 2024-06-30

[1174] The server receives this information and uses a generative AI model to create a detailed development schedule. It then analyzes the generated plan, points out ambiguities and unclear goals, and provides specific suggestions for improvement. Finally, the improved plan is returned to the user's device, and the project manager uses it to proceed with the project. In this way, the present invention helps even users who are not good at planning to easily create efficient, high-quality plans, thereby standardizing planning skills throughout the organization.

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

[1176] Step 1:

[1177] Users input the information needed for planning into the device, such as the project name, start date, end date, and major milestones, using a web browser or a dedicated application.

[1178] Input: Project name, start date, end date, milestone information

[1179] Output: Planning information entered into the terminal

[1180] Step 2:

[1181] The user device sends the entered information to the server, which converts the entered data into JSON format and sends it to the server via an HTTP request.

[1182] Input: Planning information entered into the terminal

[1183] Output: Plan information sent to the server (JSON format)

[1184] Step 3:

[1185] The server uses a generative AI model to generate a detailed plan based on the information it receives. The received data includes the project name, start date, end date, and milestone information. Based on this information, the generative AI model automatically generates each phase and task of the project.

[1186] Input: Plan information sent to the server (JSON format)

[1187] Output: Generated detailed planning data

[1188] Step 4:

[1189] The server analyzes the generated plan, using natural language processing techniques to detect ambiguous wording and unclear goals in the plan.

[1190] Input: Generated detailed planning data

[1191] Output: Information about detected ambiguous expressions and unclear targets

[1192] Step 5:

[1193] The server generates feedback based on the analysis results, such as suggestions for correcting ambiguous tasks or realizing unclear goals.

[1194] Input: Information about detected ambiguous expressions and unclear targets

[1195] Output: Specific feedback and suggestions for improvement

[1196] Step 6:

[1197] The server converts the improved planning data back into JSON format and sends it to the user's device.

[1198] Input: Specific feedback and improvement suggestions

[1199] Output: Improved planning data (JSON format)

[1200] Step 7:

[1201] The user checks the improved plan data on the device. The user reviews the final plan based on the returned data, confirms and modifies it. In this process, any unclear points are resolved and the plan is made concrete.

[1202] Input: Refined planning data (JSON format)

[1203] Output: Confirmed and revised final plan

[1204] The above are the specific processing steps in the program of this system.

[1205] (Application example 1)

[1206] 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."

[1207] Traditionally, work schedules at logistics centers have often been created manually, which is time-consuming and labor-intensive, making it difficult to create efficient plans. Furthermore, unclear goals and vague expressions are often mixed together, making it easy for problems to arise during the execution stage of the plan. There is a demand for a system that can solve these problems and automatically create and improve efficient, high-quality work schedules.

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

[1209] In this invention, the server includes a means for receiving user data and using a generative AI model to generate specific plans, a means for learning from past plan data to generate and improve plans, and a means for analyzing the generated plans to point out ambiguous expressions and unclear goals and provide suggestions for improvement, thereby enabling users to automatically create and improve efficient, high-quality work schedules.

[1210] "User terminal" means a device used by a user to input, confirm, or modify information necessary for planning, and includes computing devices such as smartphones, tablets, and personal computers.

[1211] "Data format" refers to the conversion of input information into a standardized digital format, including formats such as JSON and XML.

[1212] "Server" refers to a computer system that receives data sent from a user device and uses a generative AI model to generate, analyze, and refine plans.

[1213] A "generative AI model" refers to an artificial intelligence technology that automatically generates specific plans based on input information and makes improvements based on learning from past data.

[1214] "Analysis" refers to the process of detecting ambiguous expressions and unclear goals in the generated plans, identifying them, and improving them.

[1215] "Feedback" refers to information including improvement suggestions and suggestions generated based on the analysis results, including advice and guidelines provided to users.

[1216] A "standard format" refers to a data format that conforms to a specific protocol or standard, and is a format that maintains compatibility when exchanging or sharing data.

[1217] "Past planning data" refers to information data about plans that were previously created and executed, and serves as material for the generative AI model to learn from.

[1218] "Planning data" refers to data containing specific work schedules and steps created by a generative AI model based on information entered by the user.

[1219] This invention relates to a system that allows users to efficiently plan and improve work schedules at logistics centers. This system includes multiple means for inputting information required for planning from a user terminal, generating specific plans based on that information, and analyzing and further improving those plans.

[1220] System Overview

[1221] Users input basic information about their work schedule using their smartphone, tablet, PC, or other device. This information includes the task name, start date, end date, and key points for each task. This information is converted into a standardized data format (e.g., JSON) and sent to the server.

[1222] The server first receives the data sent by the user. The received data is analyzed by a generative AI model (e.g., GPT-4), which generates a specific work plan based on the user's input. This generative AI model learns from past planning data and creates a plan based on the factors that led to the success and failure of the plan.

[1223] The generated plan then moves to the analysis step. In this analysis process, vague expressions and unclear goals in the plan are identified, and specific improvement suggestions are generated. For example, feedback such as "The deadline for this task is vague. Please set a specific deadline" is generated.

[1224] Once the analysis and refinement is complete, the plan data is converted back into a standard format and sent back to the user's device, where the user can review the refined plan and make further corrections as needed.

[1225] Hardware / software used and data processing

[1226] Hardware used

[1227] "User devices" such as smartphones, tablets, and PCs

[1228] "Server" that generates plans and performs analysis

[1229] Software used

[1230] "Planning support app" on the user's device

[1231] Server-side "generative AI model" (e.g., GPT-4)

[1232] Data processing and calculation

[1233] 1. Transforming user input data

[1234] Convert the input plan information into JSON format

[1235] 2. Plan generation using generative AI models

[1236] Generate detailed plans based on JSON format data

[1237] 3. Plan Analysis

[1238] Identifying ambiguous language and unclear goals in generated plans

[1239] 4. Generate feedback

[1240] Generate improvement proposals

[1241] 5. Format conversion of improvement plan

[1242] Improved planning data reformatting

[1243] Specific examples

[1244] Let's imagine a scenario where a logistics center supervisor uses a smartphone to plan next week's inventory replenishment work. The following input prompts are used:

[1245] Prompt Sentence Examples

[1246] User input:

[1247] Project Name: "Warehouse Restock"

[1248] Start date: "2023-10-01"

[1249] End Date: "2023-10-10"

[1250] milestone:

[1251] Name: "Stock Arrival", Date: "2023-10-02"

[1252] Name: "Sorting", Date: "2023-10-03"

[1253] Based on this input, create a detailed, actionable and specific work plan.

[1254] In this way, the system supports the creation and improvement of efficient, high-quality plans, contributing to improved work efficiency at logistics centers.

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

[1256] Step 1:

[1257] Input from the user terminal

[1258] Users use their smartphone, tablet, PC, or other device to enter information necessary for planning, such as task name, start date, end date, and key points for each task. This input data is first entered in text format and then converted into a standard data format (e.g., JSON format) within the application. An example of input is a plan for inventory replenishment work. The user enters information such as "Project Name: Warehouse Restock," "Start Date: 2023-10-01," "End Date: 2023-10-10," and "Milestone: Stock Arrival 2023-10-02, Sorting 2023-10-03."

[1259] Step 2:

[1260] Data conversion and transmission

[1261] The user device converts the input information into JSON format and sends it to the server. This conversion process is performed using a standard library within the application (e.g., Python's json module). Specifically, the input text data is converted into a JSON object, and that data is sent to the server using an HTTP request. An example of converted data is {"project_name": "Warehouse Restock", "start_date": "2023-10-01", "end_date": "2023-10-10", "milestones": [{"name": "Stock Arrival", "date": "2023-10-02"}, {"name": "Sorting", "date": "2023-10-03"}]}.

[1262] Step 3:

[1263] Generate the plan

[1264] The server receives JSON data sent from the user's device. The server inputs this data into a generative AI model (e.g., GPT-4) to automatically generate a specific work plan. The generative AI model analyzes the factors that led to the success or failure of the plan based on the user's input data and past planning data, and generates a detailed plan. In this generation process, the received JSON data is converted into text format and used as a prompt. An example of a prompt sentence provided to the generative AI is, "User input items: Project name: Warehouse Restock, Start date: 2023-10-01, End date: 2023-10-10, Milestones: Stock Arrival 2023-10-02, Sorting 2023-10-03. Based on this input data, please create a detailed, feasible, and specific work plan."

[1265] Step 4:

[1266] Plan Analysis

[1267] The server receives the generated plan and then analyzes it. During this analysis, it uses natural language processing techniques to detect ambiguous expressions and unclear goals in the generated plan. For example, it generates feedback such as, "The deadline for this task is ambiguous. Please set a specific deadline." As a result of the analysis, ambiguous parts and unclear goals are identified and areas for improvement are extracted.

[1268] Step 5:

[1269] Generating feedback and suggesting improvements

[1270] The server generates feedback based on the analysis results and presents specific suggestions for improvement. The feedback clearly points out vague or unclear parts of the automatically generated plan and includes specific suggestions for improving them. For example, it may include a specific improvement suggestion such as, "The deadline for this task is vague. Please set a specific deadline."

[1271] Step 6:

[1272] Improvement plan format conversion

[1273] The improved plan and feedback are converted back into a standard format (e.g., JSON format). The server performs this conversion process and generates the improved plan data and feedback as a JSON object. This conversion process prepares the user device to receive the data again.

[1274] Step 7:

[1275] Return to user device

[1276] The server sends the improved plan data and feedback back to the user's device. This is done as an HTTP response, which is received by the user and displayed visually within the application. The user reviews the returned data and confirms the final plan. At this stage, the user can take the feedback and improvements into account and make further revisions as needed.

[1277] In this way, the entire system works in cooperation with the user terminal, server, and generative AI model to enable efficient planning and improvement of work plans at logistics centers.

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

[1279] This invention combines a planning support system that uses generative AI with an emotion engine. In addition to the information that users input for planning, it has the ability to acquire their emotional data and generate, analyze, and improve plans by taking that emotional information into account.

[1280] First, the user enters the information required for planning (e.g., project name, start date, and end date) from a user device such as a web browser or application. The entered information is collected and temporarily saved on the device, and the emotion engine collects the user's emotional data.

[1281] Emotional data is extracted from facial expression recognition, voice analysis, vital signs, etc., and is also sent from the device to the server. Specifically, facial expressions, tone of voice, and input speed when the user enters information are analyzed as emotional data.

[1282] The server receives the plan information and emotion data sent from the user's device. It uses an emotion engine to analyze the emotion data and optimize the plan information entered by the user. For example, if the user is feeling stressed, feedback to reduce that stress can be incorporated into the plan.

[1283] The server then activates a generation AI based on the received data. The generation AI automatically creates a specific plan based on the plan information and emotional data provided by the user. The plan generation process takes into account the user's stress level and motivation state based on the emotional data.

[1284] The server then calls an analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. It also takes into account emotional data and provides suggestions for improvement that are deemed optimal for the user. For example, it might suggest, "The deadline for this task is vague. Please set a specific deadline. Also, please schedule tasks so that you can take adequate breaks between tasks."

[1285] The improved plan data is converted back into JSON format and sent back to the user's device. The user can review the returned data and confirm it as the final plan. Feedback based on the emotional data is also displayed, allowing the user to make further revisions based on it.

[1286] As a concrete example, when a company's project manager creates a development plan for a new product, the user inputs information such as the product name, start date, end date, and major milestones from their device. At the same time, an emotion engine uses facial expression recognition and voice analysis to assess the project manager's stress level and motivation. The server receives this information and uses generative AI to create a detailed development schedule, further optimizing the plan by taking emotional data into account. For example, improvements can be made, such as adjusting the schedule to allow more rest time during periods of high stress.

[1287] In this way, the present invention supports even users who are not good at planning to easily create efficient, high-quality plans, and further improves the feasibility of plans and user satisfaction by taking into account the user's emotional state.

[1288] The processing flow will be explained below.

[1289] Step 1:

[1290] The user enters the information necessary for planning (e.g., project name, start date, and end date) into a web browser or application input form. The emotion engine installed on the user's device then analyzes the user's facial expression, tone of voice, input speed, and other factors in real time to collect emotional data.

[1291] Step 2:

[1292] The device detects that the user has clicked the "Submit" button on the input form. This triggers a process to convert the form data and emotion data into JSON format. The converted data is then sent to the server as a POST request using the HTTPS protocol.

[1293] Step 3:

[1294] The server receives the POST request sent from the device, extracts the JSON data from the request, and analyzes the plan information and emotion data.

[1295] Step 4:

[1296] The server analyzes the emotional data using an emotion engine to evaluate the user's emotional state (e.g., stress level, motivation), and optimizes the planning information based on the evaluation results.

[1297] Step 5:

[1298] The server launches a generation AI based on the received plan information. The generation AI automatically creates a specific plan using optimized user-provided data. Here, each phase and milestone of the project is specified in detail.

[1299] Step 6:

[1300] The server invokes an analysis module to analyze the generated plan. The analysis module detects ambiguous expressions and unclear goals in the plan and generates feedback to point them out. It also takes into account emotional data to provide refinements that are deemed optimal for the user.

[1301] Step 7:

[1302] The server refines the plan based on the feedback from the analysis module. For example, if the user shows high stress, it will adjust the plan to allow for appropriate rest periods between tasks. This refined plan is then converted back into JSON format.

[1303] Step 8:

[1304] The refined planning data is sent back from the server to the device, securely using the HTTPS protocol.

[1305] Step 9:

[1306] The device parses the JSON data received from the server, converts the parsed data into a user-friendly format, and displays it in a web browser or application screen. The user can then review the improved plan and make further adjustments.

[1307] As a concrete example, when a company's project manager creates a development plan for a new product, the user inputs information such as the product name, start date, end date, and major milestones from their device. At the same time, an emotion engine collects emotional data through facial recognition and voice analysis to evaluate the project manager's stress level and motivation. The server receives this information and uses generative AI to create a detailed development schedule, further optimizing the plan by taking the emotional data into account. For example, improvements can be made, such as adjusting the schedule to allow more rest time during periods of high stress.

[1308] Example 2

[1309] 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."

[1310] Conventional planning systems generate uniform schedules without considering the user's emotional state, making it impossible to provide optimal plans that address the user's stress and motivation. Furthermore, they lack the ability to point out ambiguous expressions and unclear goals after the plan is generated, and provide feedback. This reduces the feasibility of the plan and makes it difficult to improve user satisfaction.

[1311] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for collecting information and emotional data input from a user terminal and transmitting them to the server, means for generating a plan based on the received information and emotional data, means for optimizing the plan based on the emotional data, and means for analyzing the generated plan to point out ambiguous expressions and unclear goals and returning the analyzed plan and feedback to the user terminal. This makes it possible to generate a plan that takes the user's emotional state into consideration, thereby improving the feasibility of the plan and user satisfaction.

[1312] A "user terminal" is a device containing hardware and software that allows a user to input information required for planning.

[1313] "Emotional data" refers to data that indicates the user's emotional state, extracted from facial expression recognition, voice analysis, vital signs, etc.

[1314] A "server" is a system including hardware and software for receiving information and emotion data sent from a user terminal and generating, optimizing, and analyzing plans.

[1315] "Information necessary for planning" refers to basic information for planning, such as the project name, start date, end date, and major milestones.

[1316] A "generative AI model" is an artificial intelligence model that automatically creates specific plans based on planning information and emotional data provided by the user.

[1317] "Optimization" is the process of adjusting plans based on emotional data, taking into account the user's stress level and motivation state.

[1318] "Analysis" is the process of detecting and pointing out ambiguous expressions and unclear goals in the generated plan.

[1319] "Feedback" refers to suggestions for improvement or points of advice provided to users based on the analysis results.

[1320] The JSON format is a lightweight data exchange format for storing and transmitting structured data.

[1321] This invention is a system that combines a planning support system using generative AI with an emotion engine. In addition to the information that users input for planning, it has the function of acquiring the user's emotional data and generating, analyzing, and improving plans by taking that emotional information into account.

[1322] First, the user enters the information required for planning (e.g., project name, start date, end date) from a user device such as a web browser or mobile application. Specifically, to create a plan, the user enters "Project name: New product development," "Start date: October 1, 2023," "End date: September 30, 2024," etc.

[1323] Next, the device collects the input plan information and uses an emotion engine to collect the user's emotional data. Emotional data is extracted from facial expression recognition (e.g., camera), voice analysis (e.g., microphone), and vital signs (e.g., wearable devices). For example, facial expressions, tone of voice, and input speed when the user enters information are analyzed as emotional data.

[1324] The collected planning information and emotion data is sent from the device to a server, where the data is encrypted using a security protocol (e.g., HTTPS).

[1325] The server analyzes the received emotion data using an emotion engine (e.g., IBM Watson Tone Analyzer) to evaluate the user's stress level and motivation. For example, if the user is feeling high stress, the server extracts the stress level as a numerical value.

[1326] The server then optimizes the plan information entered by the user based on the analysis results. For example, if the user is feeling stressed, the server will incorporate feedback to reduce that stress into the plan.

[1327] Next, the server launches a generative AI model (e.g., OpenAI GPT-4) to automatically create a specific plan based on the user-provided plan information and emotion data. An example of an input prompt for the generative AI model is as follows:

[1328] "Create a detailed plan for product development based on the following information:

[1329] Product name: New product development

[1330] Start date: October 1, 2023

[1331] End date: September 30, 2024

[1332] Key milestones: market research, design, prototyping, mass production

[1333] User stress levels are high. Please include adequate rest time in the plan and provide suggestions for reducing stress."

[1334] Furthermore, the server analyzes the generated plan using an analysis module (e.g., a natural language processing engine) to detect ambiguous expressions and unclear goals in the plan and generate feedback, such as "The deadline for this task is vague. Please set a specific deadline. Also, please adjust your schedule so that you can take adequate rest."

[1335] The improved plan data is converted back into JSON format and sent back to the user's device. The user can review the returned data and confirm it as the final plan. Feedback based on the emotional data is also displayed, allowing the user to make further revisions.

[1336] In this way, the present invention supports users who are not good at planning to easily create efficient, high-quality plans, and further improves the feasibility of plans and user satisfaction by taking into account the user's emotional state.

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

[1338] Step 1:

[1339] Users enter the information necessary for planning. Specifically, they use a web browser or mobile app to enter planning information such as "Project name: New product development," "Start date: October 1, 2023," and "End date: September 30, 2024" into a form. The entered information is temporarily saved on the device.

[1340] Input: Planning information such as project name, start date, and finish date

[1341] Output: Temporarily saved planning information

[1342] Step 2:

[1343] The device collects emotional data. While the user is entering information, the device's camera, microphone, wearable device, etc. are used to collect emotional data such as the user's facial expressions, voice tone, input speed, and heart rate in real time.

[1344] Input: Camera footage, audio data, vital signs

[1345] Output: Collected emotion data

[1346] Step 3:

[1347] The device converts the collected planning information and emotion data into JSON format and sends it to the server using a security protocol (HTTPS).

[1348] Input: Planning information, emotion data

[1349] Output: Data sent to the server (JSON format)

[1350] Step 4:

[1351] The server receives the transmitted data and analyzes the emotional data. Using an emotion engine (e.g., IBM Watson Tone Analyzer), it evaluates the user's stress level and motivation. The analysis results are quantified, and if the stress level is high, it is rated as "High."

[1352] Input: Emotion data

[1353] Output: Sentiment analysis result (e.g., stress level "High")

[1354] Step 5:

[1355] The server then optimizes the plan based on the analysis of the emotional data. For example, if the stress level is assessed as "High," the plan will be adjusted to include more rest time.

[1356] Input: Plan information, emotion analysis results

[1357] Output: Optimized planning information

[1358] Step 6:

[1359] The server uses a generative AI model (e.g., OpenAI GPT-4) to automatically create a detailed plan based on the optimized planning information and emotion data. The generative AI model uses the following input prompt:

[1360] "Create a detailed plan for product development based on the following information:

[1361] Product name: New product development

[1362] Start date: October 1, 2023

[1363] End date: September 30, 2024

[1364] Key milestones: market research, design, prototyping, mass production

[1365] User stress levels are high. Please include adequate rest time in the plan and provide suggestions for reducing stress."

[1366] Input: Optimized planning information, emotional data

[1367] Output: Generated detailed plan

[1368] Step 7:

[1369] The server analyzes the generated plan using an analysis module (e.g., a natural language processing engine) to detect ambiguous expressions and unclear goals in the plan, and generates feedback for the user based on that information.

[1370] Input: Generated plan

[1371] Output: Feedback (e.g., "The due date for this task is vague. Please set a more specific due date. Also, please adjust your schedule so that you can take adequate rest.")

[1372] Step 8:

[1373] The server adds feedback to the optimized planning data and returns it to the device in JSON format.

[1374] Input: Optimized planning information, feedback

[1375] Output: Reply data to the terminal (JSON format)

[1376] Step 9:

[1377] The user can review the returned plan data and make any necessary corrections. Feedback based on the emotional data is also displayed, allowing the user to further refine the plan.

[1378] Input: Returned planning data, feedback

[1379] Output: Revised final plan

[1380] (Application example 2)

[1381] 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."

[1382] Because the planning process does not take into account the user's emotional state, the resulting plans may cause excessive stress for the user. Furthermore, when plans have ambiguities or unclear goals, there is a lack of efficient ways to identify and improve them. This leads to problems such as reduced feasibility of plans and reduced user satisfaction, particularly in the case of staff shift management in brick-and-mortar stores.

[1383] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for inputting information necessary for plan creation from a user terminal, means for transmitting the input information to the server, means for generating a plan based on the information received by the server, means for analyzing the generated plan and pointing out ambiguous expressions and unclear goals, means for improving the analyzed plan and returning it to the user terminal, and means for collecting emotional data and reflecting the emotional data in plan generation. This makes it possible to generate an optimal plan that takes the user's emotional state into consideration, thereby improving the feasibility of the plan and user satisfaction.

[1384] A "user terminal" is a computing device used by a user to input planning information, typically a smartphone, tablet, or personal computer.

[1385] The "server" is a central processing unit that receives data sent from user terminals and performs plan generation and analysis.

[1386] "Information necessary for planning" refers to the specific data and conditions necessary to create a plan, such as staff names, desired work days, and store opening hours.

[1387] "Emotional data" refers to data about a user's emotional state extracted from facial expression recognition, voice analysis, vital signs, etc.

[1388] "Means for generating a plan" refers to algorithms or software for creating a specific plan based on the information and emotional data required for planning received by the server.

[1389] "Means for identifying ambiguous language and unclear goals" refers to algorithms and software that automatically detect unclear points or areas that need improvement in the generated plans and provide feedback to the user.

[1390] "Means for improving the analyzed plan" refers to processes and software for optimizing the plan based on the analysis results and revising it to make it feasible and satisfactory for the user.

[1391] "Generative AI" refers to artificial intelligence that uses machine learning techniques to automatically create new plans based on data provided by users.

[1392] "Means for collecting emotional data" refers to hardware or software that extracts a user's emotional state from facial expressions, tone of voice, typing speed, etc.

[1393] A "shift schedule" refers to a timetable that allocates staff working days and hours in a rational and efficient manner.

[1394] The present invention can be implemented as a staff shift management application for brick-and-mortar stores. This application uses smartphones and tablets to input information necessary for planning and collect emotional data. This data is then sent to a server, which analyzes the data and generates an optimal shift schedule.

[1395] Specifically, the store manager, who is the user, uses a smartphone or tablet to input information such as staff member names, desired work days, and store hours, and collects emotional data through the emotion engine. Emotion data is acquired using technologies such as facial recognition and voice analysis. For example, Microsoft Azure Cognitive Services or Google Cloud Vision AI can be used as the emotion engine.

[1396] The collected data is sent from the user's device to a server. The server then uses a generative AI model (e.g., OpenAI's GPT-4) to automatically generate an optimal shift schedule based on the received plan information and emotion data. The generated plan is then passed through an analysis module to identify ambiguous expressions and unclear goals, and any necessary refinements are made. This analysis and refinement process is carried out on a cloud server, such as an AWS EC2 instance.

[1397] The improved shift schedule is converted into JSON format and sent back to the user's device. The optimized schedule can be viewed and modified on the user's device. Feedback based on emotion data is also displayed, allowing the user to make further modifications.

[1398] As a concrete example, consider a scenario in which a store manager is planning staff shifts from October 1st to October 3rd. The manager enters data using prompt statements such as:

[1399] Example prompt sentence:

[1400] "Plan staff shifts from October 1, 2023 to October 3, 2023. Generate optimal shifts based on the staff information and sentiment data below.

[1401] Staff Information:

[1402] Staff A (Desired work date: October 1st)

[1403] Staff B (Desired work date: October 2nd)

[1404] Staff C (Desired work date: October 3rd)

[1405] Emotional Data:

[1406] Staff A: Low stress level, high motivation

[1407] Staff B: Medium stress level, low motivation

[1408] Staff C: High stress level, medium motivation

[1409] Store hours are 9:00 to 18:00. The shifts generated take into account stress levels and ensure staff are able to work efficiently.

[1410] In this way, the present invention is able to generate optimal shift schedules that take into account the user's emotional state, improving feasibility and user satisfaction.

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

[1412] Step 1:

[1413] The user uses a smartphone or tablet device to input the information necessary for planning. For example, the user inputs the staff member's name, desired work date, store business hours, etc. At this time, the device temporarily saves the input plan information. The input data is recorded in the form of, for example, Staff A (desired work date: October 1st), Staff B (desired work date: October 2nd), Staff C (desired work date: October 3rd), etc.

[1414] Step 2:

[1415] The device uses an emotion engine to collect emotional data. It obtains emotional information from the user's facial expression, voice analysis, vital signs, etc. For example, it uses Microsoft Azure Cognitive Services and Google Cloud Vision AI to evaluate the user's stress level and motivation. The collected emotional data is saved in the form of: Staff A: low stress level, high motivation; Staff B: medium stress level, low motivation; Staff C: high stress level, medium motivation; etc.

[1416] Step 3:

[1417] The device sends the input plan information and emotion data to the server. The data is converted to JSON format and sent to the server using a security protocol (e.g., HTTPS). The sent data includes each staff member's name, desired work date, stress level, and motivation level.

[1418] Step 4:

[1419] The server generates a plan based on the received plan information and emotional data. Specifically, it uses a generative AI model (such as OpenAI's GPT-4) to generate an optimal shift schedule. It integrates the plan from the input data and outputs a schedule that takes into account shift balance and efficiency. For example, if staff member A is available to work on other days, it selects days with less stress based on emotional data.

[1420] Step 5:

[1421] The server analyzes the plan and points out any ambiguity or unclear goals. Using the analysis module, it detects problems in the plan and automatically generates feedback. For example, it checks whether certain staff members' shifts are consecutive, or whether break times are set appropriately.

[1422] Step 6:

[1423] The server improves the plan based on the analysis results. Based on the feedback obtained from the analysis module, the plan is revised. Specifically, it performs operations such as rearranging shifts and inserting appropriate rest periods. The improved plan is converted back into JSON format.

[1424] Step 7:

[1425] The server sends the improved plan back to the user's device. The device displays the received data, and the user can check the optimized shift schedule. For example, the new schedule will be displayed on the device screen, with Staff A's work days changed to October 1st and October 3rd, Staff B's ​​work days changed to October 2nd and October 4th, etc.

[1426] Step 8:

[1427] The user reviews the displayed plan and makes any final adjustments, either on-device or manually, based on feedback generated from emotion data. Once complete, the final shift schedule is confirmed.

[1428] The above are the processing steps in a specific embodiment of the present invention.

[1429] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

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

[1432] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1433] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1434] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1435] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1436] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1437] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1438] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1439] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1440] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1441] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1442] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1443] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1444] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1445] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1446] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1447] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1448] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1449] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1450] The following is further disclosed regarding the above embodiment.

[1451] (Claim 1)

[1452] A means for inputting information required for planning from a user terminal;

[1453] means for transmitting the input information to a server;

[1454] means for generating a plan based on the received information at the server;

[1455] A means of analyzing the generated plan to point out ambiguous expressions and unclear goals;

[1456] means for improving the analyzed plan and transmitting it back to the user terminal;

[1457] A system including:

[1458] (Claim 2)

[1459] A means for analyzing user data and generating specific plans;

[1460] including a means to learn from past planning data to generate and improve plans;

[1461] 10. The system of claim 1.

[1462] (Claim 3)

[1463] A means for analyzing the generated plan and suggesting improvements;

[1464] means for transmitting the improved plan back to the user terminal;

[1465] 10. The system of claim 1.

[1466] "Example 1"

[1467] (Claim 1)

[1468] A means for inputting information required for planning from a user terminal;

[1469] means for transmitting the input information to a server;

[1470] A means for generating a specific plan using a generative AI model based on the information received by the server;

[1471] A means of analyzing the generated plan to point out ambiguous expressions and unclear goals;

[1472] means for improving the analyzed plan and transmitting it back to the user terminal;

[1473] A system including:

[1474] (Claim 2)

[1475] A means for analyzing user data and generating specific plans;

[1476] including a means to learn from past planning data to generate and improve plans;

[1477] 10. The system of claim 1.

[1478] (Claim 3)

[1479] a means for analyzing the generated plan and providing feedback for improvement;

[1480] means for transmitting the changed plan data back to the user terminal;

[1481] 10. The system of claim 1.

[1482] "Application Example 1"

[1483] (Claim 1)

[1484] A means for inputting information required for planning from a user terminal;

[1485] means for converting input information into a data format and transmitting the data to a server;

[1486] a means for using a generative AI model to generate a plan based on the information received at the server;

[1487] A means of analyzing the generated plan to point out ambiguous expressions and unclear goals;

[1488] a means of improving the analyzed plan and providing feedback;

[1489] means for transmitting the refined planning data back to the user terminal;

[1490] A system including:

[1491] (Claim 2)

[1492] a means for using a generative AI model to generate a specific plan based on user input; and

[1493] including means for learning from past planning data to generate and improve plans;

[1494] 10. The system of claim 1.

[1495] (Claim 3)

[1496] A means for analyzing the generated plan and suggesting improvements;

[1497] means for converting the improved plan into a standard format and transmitting it back to the user terminal;

[1498] 10. The system of claim 1.

[1499] "Example 2: Combining Emotion Engines"

[1500] (Claim 1)

[1501] A means for inputting information required for planning from a user terminal;

[1502] means for collecting input information and emotion data and transmitting them to a server;

[1503] means for generating a plan based on the received information and emotion data at the server;

[1504] A means of optimizing plans based on emotional data;

[1505] A means of analyzing the generated plan to point out ambiguous expressions and unclear goals;

[1506] means for transmitting the analyzed plan and feedback back to the user terminal;

[1507] A system including:

[1508] (Claim 2)

[1509] A means for analyzing user data and sentiment data and generating a specific plan;

[1510] a means for learning from past planning data to generate and improve plans;

[1511] 10. The system of claim 1.

[1512] (Claim 3)

[1513] A means for analyzing the generated plan and presenting an improvement proposal based on the emotion data;

[1514] means for transmitting the improved plan and feedback back to the user terminal;

[1515] 10. The system of claim 1.

[1516] "Application example 2 when combining emotion engines"

[1517] (Claim 1)

[1518] A means for inputting information required for planning from a user terminal;

[1519] means for transmitting the input information to a server;

[1520] means for generating a plan based on the received information at the server;

[1521] A means of analyzing the generated plan to point out ambiguous expressions and unclear goals;

[1522] means for improving the analyzed plan and transmitting it back to the user terminal;

[1523] A means for collecting emotion data and reflecting the emotion data in plan generation;

[1524] A system including:

[1525] (Claim 2)

[1526] A means for analyzing user data and generating specific plans;

[1527] a means for learning from past planning data to generate and improve plans;

[1528] Generate optimal shift schedules based on emotional data

[1529] means,

[1530] 10. The system of claim 1.

[1531] (Claim 3)

[1532] A means for analyzing the generated plan and suggesting improvements;

[1533] means for transmitting the improved plan back to the user terminal;

[1534] Considering emotional data, the generated plan is optimized based on the user's emotional state

[1535] means,

[1536] 10. The system of claim 1. [Explanation of symbols]

[1537] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for inputting information required for planning from a user terminal; means for transmitting the input information to a server; means for generating a plan based on the received information at the server; A means of analyzing the generated plan to point out ambiguous expressions and unclear goals; means for improving the analyzed plan and transmitting it back to the user terminal; A system including:

2. A means for analyzing user data and generating specific plans; including a means to learn from past planning data to generate and improve plans; The system of claim 1 .

3. A means for analyzing the generated plan and suggesting improvements; means for transmitting the improved plan back to the user terminal; The system of claim 1 .

Images