system

Abstract

We provide the system. [Solution] Means for creating and updating tasks, A means of visualizing the progress of a task, A means to detect and notify about delays in task progress, A system that includes this.

Description

Technical Field

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

Background Art

[0002] Patent Document 1 discloses a method for controlling a persona chatbot, which is performed by at least one processor, including steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to an explanation of a chatbot character, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance as a response to the user utterance.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] In a conventional task management system, the progress status of tasks had to be manually checked, and it was difficult to detect early the risk in case of progress delay. Also, a great deal of labor was required for progress confirmation, which was a factor hindering efficient business management. The present invention aims to solve these problems by providing a system that realizes automation and visualization of task management, monitors the progress status of tasks in real time, detects progress delay early, and gives appropriate notifications.

Means for Solving the Problems

[0005] This invention first provides means for users to create and update tasks. Next, it provides means for visualizing the progress of tasks, enabling users to understand the status of tasks in real time. Furthermore, it provides means for detecting delays in task progress and determining the risk, thereby identifying tasks that may be delayed at an early stage. Finally, when a delay risk is determined, it provides means for notifying the appropriate person in charge via email or push notification, thereby facilitating a quick response. Through these means, users can efficiently manage tasks, reduce the effort required for unnecessary progress checks, and mitigate risks.

[0006] "Means for creating and updating tasks" refers to features that allow users to input new tasks and later modify or update their progress and detailed information.

[0007] "Means for visualizing task progress" refers to a function that visually displays the progress of a task, allowing users to check the task's progress in real time.

[0008] "Means for detecting and notifying about delays in task progress" refers to a system that determines when a task is behind schedule and informs the user of that information, including when and how.

[0009] A "task" refers to a unit of work and related information that must be performed to achieve a specific goal.

[0010] "Progress status" refers to an indicator or degree that shows how much of a task has been completed.

[0011] "Visualization" refers to presenting data and information in visual forms such as graphs, charts, and lists.

[0012] "Risk" refers to the possibility that a task may not be completed as planned, and the extent of the problems that may result from this.

[0013] "Judgment" refers to the process of making a judgment based on specific circumstances or conditions, as well as the result of that judgment.

[0014] "Notification" refers to the means and actions of informing a user of specific information.

[0015] "Email" refers to a means of communication used to send and receive text and files over the internet.

[0016] "Push notifications" refer to a method of notifying users in real time by pushing information to their mobile devices or web browsers. [Brief explanation of the drawing]

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

Mode for Carrying Out the Invention

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

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

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

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

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

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

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

[0025] [First Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0038] This invention is a system that manages tasks created and updated by users, visualizes the progress of tasks, detects delay risks, and provides timely notifications. The implementation of this system is described below.

[0039] Task creation and update

[0040] When a user creates a task, they first enter the task details (task name, due date, assignee, dependent tasks, etc.) from their device. The device then sends this information to the task management server in JSON format. The server saves the received data to its database, and a new task is created. For example, a user can create a task called "Design Project X" and set its due date to October 10, 2023.

[0041] When a user updates the progress of a task, they enter the current progress percentage (e.g., 50%) from their terminal and send it to the server. The server updates the progress data in the database and reflects the information in other tasks related to that task. For example, a user can set the progress of "Design Project X" to 50%.

[0042] Task visualization

[0043] To check the progress of tasks, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device visualizes the retrieved task information in a format such as a Gantt chart or calendar. This makes it easier for the user to see the progress of all tasks at a glance. For example, the progress of "Project X Design" is displayed as 50% on the Gantt chart.

[0044] Risk notification

[0045] To detect the risk of tasks falling behind schedule, the server periodically monitors the progress of all tasks. The server compares the progress of tasks with their deadlines to identify tasks that are at risk of not meeting their deadlines. This risk assessment is based on the remaining time and the required progress. For example, if task "Development of Project Y" is 20% complete and its deadline is November 1, 2023, the server will determine that this task is behind schedule.

[0046] If a delay risk is detected, the server sends a notification to the person in charge of the relevant task via email or push notification. This allows the person in charge to take immediate action. For example, the server sends a notification to the person in charge of "Development of Project Y" stating, "Task 'Development of Project Y' is likely to be delayed."

[0047] These features allow users to eliminate wasted time on progress checks, manage tasks efficiently, and detect and address risks early. The system of this invention automates, visualizes, and provides timely notifications for task management, thereby improving operational efficiency and avoiding risks.

[0048] The following describes the processing flow.

[0049] Task creation and update

[0050] Task creation

[0051] Step 1:

[0052] The user enters task details (task name, due date, assignee, dependent tasks, etc.) on their device. This information is entered as a form.

[0053] Step 2:

[0054] The terminal converts the entered task information into JSON format and sends a POST request to the task management server.

[0055] Step 3:

[0056] The server parses the received request and extracts task information.

[0057] Step 4:

[0058] The server saves task information to the database. A task ID is also issued for newly created tasks.

[0059] Step 5:

[0060] The server verifies that the task was created successfully and returns a success message to the terminal.

[0061] Task update

[0062] Step 1:

[0063] To update the progress, the user enters the task's progress percentage (e.g., 50%) on their device.

[0064] Step 2:

[0065] The terminal converts the update information into JSON format and sends a PUT request to the task management server.

[0066] Step 3:

[0067] The server parses the received request and extracts the target task ID and the updated progress information.

[0068] Step 4:

[0069] The server updates the progress information of the relevant task in the database.

[0070] Step 5:

[0071] The server confirms that the task progress has been successfully updated and returns a success message to the terminal.

[0072] Task visualization

[0073] Step 1:

[0074] To check the progress of all tasks, the user requests task information on their device. This is sent as a GET request to the server.

[0075] Step 2:

[0076] The server retrieves progress information for all tasks from the database.

[0077] Step 3:

[0078] The server converts the acquired task information into JSON format and sends it back to the terminal.

[0079] Step 4:

[0080] The terminal analyzes the received task information and displays it to the user in a Gantt chart or calendar format.

[0081] Risk notification

[0082] Step 1:

[0083] The server periodically retrieves progress information for all tasks from the database and compares it with the task deadlines.

[0084] Step 2:

[0085] The server compares progress with deadlines and identifies tasks that may not be completed by the deadline.

[0086] Step 3:

[0087] The server retrieves the information of the person responsible for the identified risk task and generates a notification indicating a risk of delay.

[0088] Step 4:

[0089] The server sends the generated notification content to the responsible person's terminal via email or push notification.

[0090] Step 5:

[0091] The device displays received notifications to the user and informs them about the risk of delays.

[0092] (Example 1)

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

[0094] Traditional task management systems had problems with efficiently creating and updating tasks, visualizing progress, and notifying users of delay risks. In particular, when multiple tasks were dependent on each other or in large-scale projects, it was difficult to grasp progress in real time and detect delay risks early, which raised concerns about a decrease in overall work efficiency.

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

[0096] In this invention, the server includes means for the user to input detailed task information, means for transmitting the input information to the server, means for the server to store the received information in a database, means for the user to update the task progress, means for transmitting the progress data to the server, means for the server to update the database with the received progress data, means for the user to send a request to retrieve task information, means for the server to retrieve all task information from the database and send it back to the terminal, means for the terminal to visualize the received task information, means for the server to periodically monitor the task progress and evaluate the risk of delay, and means for notifying the evaluation results. This enables real-time task management and visualization of progress, as well as rapid detection and notification of delay risks.

[0097] A "user" refers to an individual or legal entity that uses the system to create tasks, update their progress, or check their progress.

[0098] A "terminal" refers to an electronic device used by a user to input information or display data from a server.

[0099] A "server" refers to a computing system used for managing task information, storing data, monitoring progress, and providing notifications.

[0100] A "database" refers to an information management system used by a server to store task information and progress data.

[0101] A "task" refers to a series of actions or activities that a user creates to achieve a specific objective.

[0102] "Progress status" refers to information indicating the extent to which a task has been completed.

[0103] "Visualization" refers to the process of displaying the progress of a task in an easy-to-understand way for the user.

[0104] "Risk" refers to a situation where the progress of a task may fall behind schedule.

[0105] "Notification" refers to a means of communication used by a server to inform the person in charge of a task about the risk of delays.

[0106] "JSON format" is an abbreviation for JavaScript (registered trademark) Object Notation, and refers to a lightweight data exchange format for structurally representing data.

[0107] This invention provides a system for efficiently managing user-created and updated tasks, visualizing progress, and detecting and notifying users of delay risks at an early stage. The configuration for implementing this system is described below.

[0108] Task creation and update

[0109] The user first enters task details (task name, due date, assignee, dependent tasks, etc.) into the terminal. This information is converted to JSON format and sent to the task management server. The server saves the received data to its database, and a new task is created. For example, a user might create a task called "Design Project X" and set the due date to October 10, 2023. When the user updates the task's progress, they enter the progress percentage (e.g., 50%) from the terminal and send it to the server. The server saves the received progress data to its database and reflects the information in other tasks related to that task. For example, a user might set the progress of "Design Project X" to 50%.

[0110] Task visualization

[0111] To check the progress of a task, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device visualizes the retrieved task information in a format such as a Gantt chart or calendar, allowing the user to see the progress of all tasks at a glance. For example, the progress of "Project X Design" may be displayed as 50% on the Gantt chart.

[0112] Risk notification

[0113] The server periodically monitors the progress of all tasks, comparing progress with deadlines to assess the risk of delay. This assessment is based on the remaining time and required progress, and if there is a risk of delay, the server sends a notification to the person in charge of the task via email or push notification. For example, if task "Development of Project Y" is 20% complete and due on November 1, 2023, the server will determine that this task is behind schedule and send a notification to the person in charge stating, "Task 'Development of Project Y' is likely to be delayed."

[0114] These features allow users to eliminate wasted time on progress checks, manage tasks efficiently, and detect and address risks early. The system of this invention automates, visualizes, and provides timely notifications for task management, thereby improving operational efficiency and avoiding risks.

[0115] Command example

[0116] By using a generative AI model, you can receive explanations and help for each function by entering prompts like the following.

[0117] Examples of prompts for a generative AI model:

[0118] Please explain each function of the following task management system in clear, natural language.

[0119] Task creation and update

[0120] When a user creates a task, they enter the task details (task name, due date, assignee, dependent tasks, etc.) from their device. The device sends this information to the task management server in JSON format. The server saves the received data to its database, and a new task is created.

[0121] Example: A user creates a task called "Design Project X" and sets the deadline to October 10, 2023.

[0122] When a user updates the progress of a task, they enter the current progress percentage (e.g., 50%) from their device and send it to the server. The server updates the progress data in the database and reflects the information in other tasks related to that task.

[0123] Specific example: The user sets the progress of "Project X Design" to 50%.

[0124] Task visualization

[0125] To check the progress of their tasks, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device then visualizes the retrieved task information in a format such as a Gantt chart or calendar.

[0126] Specific example: The progress of "Project X Design" is displayed as 50% on the Gantt chart.

[0127] Risk notification

[0128] The server periodically monitors the progress of all tasks to detect the risk of tasks falling behind schedule. The server compares task progress with deadlines to identify tasks at risk of missing deadlines. This risk assessment is based on the remaining time and the required progress.

[0129] Specific example: If task "Development of Project Y" is 20% complete and due on November 1, 2023, the server will determine that this task is behind schedule.

[0130] If a delay risk is detected, the server will send a notification to the person responsible for the relevant task via email or push notification.

[0131] Specific example: The server sends a notification to the person in charge of "Development of Project Y" stating, "Task 'Development of Project Y' is likely to be delayed."

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

[0133] Step 1:

[0134] The user enters the task details.

[0135] The user uses their device to enter details about the new task (task name, due date, assignee, dependent tasks, etc.).

[0136] Input: User-entered task name "Project X Design", deadline "October 10, 2023", assignee "Taro Yamada", dependent task "Project W Review", etc.

[0137] Data processing: The terminal converts the entered information into JSON format.

[0138] Output: Task information in JSON format: "{'taskName': 'Project X Design', 'deadline': '2023-10-10', 'assignee': 'Taro Yamada', 'dependency': 'Project W Review'}".

[0139] Step 2:

[0140] The device sends task data to the server.

[0141] The terminal sends the converted JSON-formatted task information to the task management server.

[0142] Input: Task information in JSON format.

[0143] Data processing: None (simple data transfer).

[0144] Output: Task information sent to the server.

[0145] Step 3:

[0146] The server saves the task information it receives to the database.

[0147] The server saves the received task information to the database and registers it as a new task.

[0148] Input: Received task information in JSON format.

[0149] Data processing: Convert the data to a format suitable for the database and save it as a new record in the database.

[0150] Output: A new task record added to the database.

[0151] Step 4:

[0152] The user enters the task progress.

[0153] The user uses their device to input the progress of an existing task (e.g., 50%).

[0154] Input: User-entered task name "Project X Design", progress "50%".

[0155] Data processing: The terminal converts the entered information into JSON format.

[0156] Output: Progress information in JSON format: "{'taskName': 'Project X Design', 'progress': 50}".

[0157] Step 5:

[0158] The device sends progress data to the server.

[0159] The terminal sends the converted JSON-formatted progress information to the task management server.

[0160] Input: Progress information in JSON format.

[0161] Data processing: None (simple data transfer).

[0162] Output: Progress information sent to the server.

[0163] Step 6:

[0164] The server updates the database with progress information.

[0165] The server saves the received progress information to the database and updates the progress status of the relevant task. It also reflects the information in other tasks related to that task.

[0166] Input: Received progress information in JSON format.

[0167] Data processing: Update the progress of the relevant task in the database. Also update related tasks.

[0168] Output: Updated task records in the database.

[0169] Step 7:

[0170] A user submits a request to retrieve task information.

[0171] The user uses their terminal to send a request to the server to retrieve information about all tasks.

[0172] Input: Task information retrieval request.

[0173] Data processing: None (simple request).

[0174] Output: The request sent to the server.

[0175] Step 8:

[0176] The server retrieves task information from the database.

[0177] The server retrieves information on all tasks from the database and converts it to JSON format.

[0178] Input: Task information retrieval request.

[0179] Data processing: Execute database queries to retrieve task information and convert it to JSON format.

[0180] Output: Task information in JSON format.

[0181] Step 9:

[0182] The server sends task information back to the terminal.

[0183] The server returns the converted task information in JSON format to the terminal.

[0184] Input: Task information in JSON format.

[0185] Data processing: None (simple data transfer).

[0186] Output: Task information sent to the terminal.

[0187] Step 10:

[0188] The device visualizes task information.

[0189] The device uses the received task information to visualize it in a Gantt chart or calendar format.

[0190] Input: Received task information in JSON format.

[0191] Data processing: Convert task information into Gantt charts and calendar formats.

[0192] Output: Displayed task information (e.g., "Project X Design" progress: 50%).

[0193] Step 11:

[0194] The server monitors the progress of the task.

[0195] The server periodically retrieves the progress of all tasks from the database, compares the progress with the deadline, and assesses the risk of delays.

[0196] Input: All task information in the database.

[0197] Data processing: Compare progress with deadlines and assess the risk of delays.

[0198] Output: Delay risk assessment results.

[0199] Step 12:

[0200] The server will notify you of the risk of delay.

[0201] The server sends notifications via email or push notification to the person responsible for the task where a delay risk has been identified.

[0202] Input: Delay risk assessment results.

[0203] Data processing: Generate and send a notification message.

[0204] Output: Notification sent to the person in charge (e.g., "Task 'Development of Project Y' is likely to be delayed.").

[0205] (Application Example 1)

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

[0207] Traditional task management systems required users to use desktop or mobile devices to create tasks, update progress, and receive notifications about delay risks, resulting in cumbersome manual data entry. Furthermore, they often lacked real-time visualization of progress and risk notifications, making quick responses difficult.

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

[0209] In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of delays in task progress, means for inputting tasks and updating their progress using smart glasses, means for visualizing the progress displayed on the smart glasses, and means for notifying the smart glasses of delay risks. This enables users to manage tasks hands-free, check progress and risks in real time, and take quick countermeasures.

[0210] "Means for creating and updating tasks" refers to a function that allows users to input new tasks and send detailed information about those tasks to the server for storage in the database.

[0211] "Means of visualizing task progress" refers to a function where the server retrieves task information from a database and displays it in a format that is easy for the user to understand visually.

[0212] "A means of detecting and notifying about delays in task progress" refers to a function in which the server compares the progress and deadline of a task, identifies tasks at risk of delay, and notifies the user of that information.

[0213] "A means of inputting tasks and updating progress using smart glasses" refers to a function that allows users to input detailed task information and progress using voice commands or gestures through smart glasses, and to send that information to a server.

[0214] "Means of visualizing progress displayed on smart glasses" refers to a function that displays the progress of tasks on the smart glasses' screen in the form of a Gantt chart or calendar.

[0215] "A means of providing delay risk notifications to smart glasses" refers to a function that displays delay risk notifications sent from the server on smart glasses, enabling users to respond quickly.

[0216] Modes for carrying out the invention

[0217] This invention is a system that manages tasks created and updated by users, visualizes the progress of tasks, detects delay risks, and provides timely notifications. Specific embodiments thereof are described below.

[0218] Task creation and update

[0219] When a user creates a task, they input task details (task name, due date, assignee, dependent tasks, etc.) into the smart glasses using voice commands or gestures. The smart glasses send this information to the task management server in JSON format, and the server stores the received data in its database and creates a new task. For example, a user can create a task called "Design a New Project" and set the due date to a specific date.

[0220] To update task progress, the user similarly inputs the current progress level into their smart glasses using voice commands or gestures and sends it to the server. The server updates the progress data in its database and reflects the information in other tasks related to that task. For example, a user can set the progress of "Design a New Project" to 50%.

[0221] Task visualization

[0222] To check the progress of tasks, the user sends a request to the server via smart glasses to retrieve all tasks. The server retrieves task information from the database and returns it to the smart glasses in JSON format. The progress of tasks is displayed on the smart glasses' screen in the form of a Gantt chart or calendar. This makes it easy for the user to see the progress of all tasks at a glance. For example, the progress of "Designing a New Project" is displayed on the Gantt chart.

[0223] Risk notification

[0224] To detect the risk of tasks falling behind schedule, the server periodically monitors the progress of all tasks. The server compares the progress of tasks with their deadlines to identify tasks that are at risk of not being met. This risk assessment is based on the remaining time and the required progress. For example, if a task is 20% complete and has a deadline of a specific date, the server will determine that this task is behind schedule.

[0225] If a delay risk is detected, the server sends a push notification to the smart glasses, displaying the notification to the person responsible for the relevant task. This allows the person responsible to take immediate action. For example, the server might send a notification to the person responsible for "Designing a New Project" stating, "This task is likely to be delayed."

[0226] Specific example

[0227] For example, consider a task management scenario in a factory. The user (worker) wears smart glasses and inputs the next task using voice or gestures. The worker can create a new task, such as "check the assembly line," and update its progress in real time. The server monitors the task's progress and sends a notification to the smart glasses if the progress is behind schedule despite the approaching deadline, alerting the user to the risk.

[0228] Example of a prompt

[0229] Please enter the task details. Include the task name, due date, assignee, and dependent tasks.

[0230] This system allows users to manage tasks effortlessly and perform their work efficiently. It also enables early detection of risks and prompt action.

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

[0232] Step 1:

[0233] The user inputs task details into smart glasses using voice commands or gestures. This includes information such as the task name, due date, assignee, and dependent tasks. The smart glasses convert this information into JSON format and send it to the task management server.

[0234] Input: Enter task details (task name, due date, assignee, dependent tasks) using voice or gestures.

[0235] Processing: Smart glasses analyze voice or gestures and convert them into JSON format.

[0236] Output: Task information converted to JSON format is sent to the server.

[0237] Step 2:

[0238] The server saves the received task information to the database and creates a new task. The server parses the JSON data and writes it to the database in the appropriate format.

[0239] Input: Task information in JSON format.

[0240] Processing: The server parses the JSON and saves it to the database.

[0241] Output: A new task is added to the database.

[0242] Step 3:

[0243] The user updates task progress via smart glasses. Progress is entered via voice or gestures, and the smart glasses convert this into JSON format and send it to the server.

[0244] Input: Enter the progress percentage (e.g., 50%) using voice or gestures.

[0245] Processing: The smart glasses analyze the input and convert it to JSON format.

[0246] Output: Sends progress information in JSON format to the server.

[0247] Step 4:

[0248] The server updates the database with the received progress information, and the progress is reflected in the relevant task and related tasks. The server analyzes the progress information and updates the progress of the relevant task.

[0249] Input: Progress information in JSON format.

[0250] Processing: The server parses the JSON and updates the progress of the corresponding task in the database.

[0251] Output: Task information in the database is updated.

[0252] Step 5:

[0253] The user uses smart glasses to check the progress of all tasks. A request to retrieve all tasks is sent from the smart glasses to the server.

[0254] Input: A request to check the progress of all tasks.

[0255] Processing: The server retrieves task information from the database and sends it back to the smart glasses in JSON format.

[0256] Output: Task information in JSON format is sent to the smart glasses.

[0257] Step 6:

[0258] The smart glasses display received task information in Gantt chart and calendar formats. This allows users to check the progress of all tasks hands-free.

[0259] Input: Task information in JSON format.

[0260] Processing: Smart glasses parse the JSON data and convert it into a Gantt chart or calendar for display.

[0261] Output: Visualized task progress is displayed on the smart glasses' screen.

[0262] Step 7:

[0263] The server periodically monitors the progress of tasks and detects tasks at risk of delay. The server compares the progress with the deadline to make a determination.

[0264] Input: Task progress information and deadline information from the database.

[0265] Processing: The server compares progress and deadlines to identify tasks at risk of delay.

[0266] Output: Delay risk assessment result.

[0267] Step 8:

[0268] When a delay risk is detected, the server sends a push notification to the smart glasses, displaying the notification to the person responsible for the relevant task. This allows the user to take immediate action.

[0269] Input: Delay risk assessment result.

[0270] Processing: The server generates a push notification and sends it to the smart glasses.

[0271] Output: A delay risk notification is displayed on the smart glasses.

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

[0273] This invention provides a more efficient and satisfying work environment by combining a task management system with an emotion engine, enabling notifications and task management based on the user's emotions. This system includes means for creating and updating tasks, means for visualizing progress, means for detecting and notifying of delays in progress, and an emotion engine that recognizes the user's emotions.

[0274] Task creation and update

[0275] Task creation:

[0276] The user enters task details on their device. The device converts this information into JSON format and sends it to the task management server. The server stores the task information in its database and generates a new task.

[0277] Task update:

[0278] The user inputs the progress status on the terminal, and the terminal converts this information into JSON format and sends it to the server. The server updates the progress information of the corresponding task on the database.

[0279] Visualization of tasks

[0280] The user sends a request from the terminal to the server to check the progress status of all tasks. The server retrieves the information of all tasks from the database and returns it to the terminal in JSON format. The terminal analyzes the task information and displays it in the form of a Gantt chart or a calendar.

[0281] Risk notification

[0282] The server periodically retrieves the progress information of all tasks from the database and compares it with the deadlines of the tasks. By comparing the progress status and the deadlines, it identifies tasks that may not be completed within the deadlines. The person in charge of the identified risk tasks is notified of the delay risk through email or push notifications.

[0283] Emotion engine

[0284] Emotion recognition:

[0285] The server analyzes the user's input data, operation history, and other related data to recognize the user's emotion. The emotion engine uses a machine learning model to determine the user's emotion state (e.g., stress, satisfaction, anxiety). The information when the user inputs or updates a task is also sent to the emotion engine and used for analysis.

[0286] Notification based on emotion:

[0287] The emotion engine analyzes the user's emotion state and generates notifications according to specific emotion states. For example, when the user is feeling stressed, the server notifies a proposal of "relax". Also, when the risk of progress delay is high, the server makes a notification considering the user's emotion state.

[0288] Displaying sentiment data:

[0289] The server also analyzes emotional data collected from multiple users and provides a function to display the emotional trends of the entire team. This allows administrators to understand the emotional state of the entire team and take necessary actions. For example, if many team members are experiencing stress, the server will provide this information to the administrator and suggest countermeasures.

[0290] Specific example

[0291] Example 1:

[0292] A user creates a task called "Design Project A" and sets the deadline to November 30, 2023. If progress starts to fall behind, the server detects this and notifies the user. At the same time, if the emotion engine determines that the user's stress level is high, it also makes suggestions for stress reduction.

[0293] Example 2:

[0294] In projects involving multiple team members, if overall progress is behind schedule, the server uses an emotion engine to analyze the emotional state of all team members. It then provides the results to the administrator and suggests appropriate actions.

[0295] These features allow the task management system to not only manage task progress but also contribute to managing user emotions, thereby improving overall work efficiency and user satisfaction. The system of this invention realizes a more human-centered task management environment by taking user emotions into consideration.

[0296] The following describes the processing flow.

[0297] Task creation and update

[0298] Task creation

[0299] Step 1:

[0300] The user inputs the detailed information of a new task on the terminal. Specifically, a form is used to input items such as task name, deadline, assignee, and dependent tasks.

[0301] Step 2:

[0302] The terminal converts the input task information into JSON format and sends a POST request to the task management server.

[0303] Step 3:

[0304] The server analyzes the received request and extracts the task information.

[0305] Step 4:

[0306] The server saves the task information in the database. At the same time, it generates an ID for the newly created task.

[0307] Step 5:

[0308] The server confirms that the task has been successfully created and returns a success message and the new task ID to the terminal.

[0309] Task Update

[0310] Step 1:

[0311] The user inputs the progress (e.g., 50%) on the terminal to update the progress of the task. An update form or interactive element is used.

[0312] Step 2:

[0313] The terminal converts the progress information into JSON format and sends a PUT request to the task management server.

[0314] Step 3:

[0315] The server analyzes the received request and extracts the target task ID and progress information.

[0316] Step 4:

[0317] The server updates the progress information of the relevant task in the database.

[0318] Step 5:

[0319] The server confirms that the task progress has been successfully updated and sends a success message back to the terminal.

[0320] Task visualization

[0321] Step 1:

[0322] To check the progress of all tasks, the user requests task information on their device. This is sent as a GET request to the server.

[0323] Step 2:

[0324] The server retrieves progress information for all tasks from the database.

[0325] Step 3:

[0326] The server converts the acquired task information into JSON format and sends it back to the terminal.

[0327] Step 4:

[0328] The terminal analyzes the received task information and displays it to the user in a Gantt chart or calendar format.

[0329] Risk notification

[0330] Step 1:

[0331] The server periodically retrieves progress information for all tasks from the database and compares it with the task deadlines.

[0332] Step 2:

[0333] The server compares progress with deadlines and identifies tasks that may not be completed by the deadline.

[0334] Step 3:

[0335] The server retrieves the information of the person responsible for the identified risk task and generates a notification indicating a risk of delay.

[0336] Step 4:

[0337] The server sends the generated notification content to the responsible person's terminal via email or push notification.

[0338] Step 5:

[0339] The device displays received notifications to the user and informs them about the risk of delays.

[0340] Emotional Engine

[0341] Step 1:

[0342] The server periodically collects user input data and operation history, and analyzes it using an emotion engine.

[0343] Step 2:

[0344] The emotion engine uses machine learning models to determine the user's emotional state based on collected data. For example, it can identify stress levels, satisfaction levels, and so on.

[0345] Step 3:

[0346] When a user enters or updates a task, data from the device is sent to the sentiment engine and used for sentiment analysis.

[0347] Step 4:

[0348] The emotion engine generates appropriate notifications for the user based on the determined emotional state. For example, if the user is experiencing high stress, it will suggest relaxation techniques.

[0349] Step 5:

[0350] The server sends the generated notification content to the user's device via email or push notification.

[0351] Step 6:

[0352] The server analyzes the emotional data of multiple users and generates data to display the emotional trends of the entire team.

[0353] Step 7:

[0354] Administrators can monitor the emotional state of the entire team through their devices and take necessary measures. For example, if many members are experiencing high levels of stress, they can use that information to provide support.

[0355] (Example 2)

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

[0357] Traditional task management systems can track task progress and notify users of delays, but they lack the ability to consider users' emotional states, making efficient task management difficult. In particular, ignoring emotional factors such as user stress and satisfaction can hinder task progress. Furthermore, the lack of means for managers to understand the emotional dynamics of the entire team makes appropriate responses difficult.

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

[0359] In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of delays in task progress, means for recognizing user emotions and notifying based on the analysis results, and means for analyzing user and multiple user emotion data and presenting it to the administrator. This enables efficient and highly satisfying task management that takes into account the emotional state of users.

[0360] A "task" refers to a unit of work or task that a user performs to achieve a specific objective.

[0361] "Means" refers to the methods or mechanisms that a system uses to achieve a specific function.

[0362] A "server" refers to a computer system that provides or processes data in response to requests from clients.

[0363] A "terminal" refers to a device that a user uses to access and operate a system. Examples include personal computers, smartphones, and tablets.

[0364] "Users" refer to the people who use this system to create, update, and manage tasks.

[0365] "Means for creating and updating tasks" refers to a system that provides users with the functionality to create new tasks and modify information about existing tasks.

[0366] "Means of visualizing task progress" refers to a system that provides a function to visually display the progress of tasks. For example, it can be displayed in a Gantt chart or calendar format.

[0367] "Means for detecting and notifying about delays in task progress" refers to a system that compares the progress of a task with its deadline and provides a function to notify the user if there is a risk of delay.

[0368] "A means of recognizing user emotions and providing notifications based on the analysis results" refers to a system that analyzes user input data and operation history, recognizes the user's emotional state, and provides a function to generate notifications corresponding to specific emotional states.

[0369] "Means of analyzing and presenting emotional data of users or multiple users to administrators" refers to a system that provides functions for collecting and analyzing emotional data of users or entire teams and providing the results to administrators.

[0370] "Notification" refers to a means by which a system communicates information to a user. Specifically, this includes email and push notifications.

[0371] "Visualization" refers to the visual display of data and information. This includes, for example, displaying data using graphs and charts.

[0372] An "emotion engine" refers to a software component that includes a machine learning model for analyzing and recognizing a user's emotional state.

[0373] A "machine learning model" refers to an algorithm that learns from large amounts of data and uses that data to perform inferences and predictions.

[0374] This invention is a task management system that takes user emotions into consideration, and by providing means for creating and updating tasks, means for visualizing progress, means for detecting and notifying of progress delays, and an emotion engine, it provides an efficient and highly satisfying work environment.

[0375] Task creation and update

[0376] Task creation:

[0377] The user enters details such as the task name, due date, and description into a task creation form on their device. This detailed information is converted to JSON format by the device and sent to the server. The server parses the received JSON data and saves it as a new task in the database. For example, if a user creates a task called "Design Project A" and sets the due date to November 30, 2023, the device converts this information to JSON format and sends it to the server via an HTTP POST request.

[0378] Task update:

[0379] The user enters the progress status of an existing task (e.g., 50%) on their device. This information is also converted to JSON format by the device and sent to the server. The server reflects the received progress information in the corresponding task in the database and updates the progress status.

[0380] Task visualization

[0381] When a user sends a request from their device to check the progress of all tasks, the server retrieves information on all tasks from the database and sends it back in JSON format. The device then parses the received JSON data and displays it visually in a Gantt chart or calendar format. This allows the user to grasp the progress of each task at a glance.

[0382] Risk notification

[0383] The server periodically retrieves progress information for all tasks from the database and compares the progress with the deadline. If a task is found to be behind schedule, the server notifies the task's assignee of the delay risk via email or push notification. For example, if a task due on November 30, 2023, is less than 20% complete, it will be flagged as a risk task and the assignee will be notified.

[0384] Emotional Engine

[0385] Emotion recognition:

[0386] The server collects user input data and operation history, and uses an emotion engine to analyze the user's emotional state. The emotion engine uses machine learning models to determine the user's stress, satisfaction, and anxiety levels. For example, if the frequency of task updates is low and there are signs of anxiety in the operation history, the server will determine that the user's stress level is high.

[0387] Emotion-based notifications:

[0388] Based on the emotion engine's analysis of the user's emotional state, the server generates notifications tailored to that specific emotional state. For example, if the user is feeling stressed, it sends a notification suggesting a break to relax.

[0389] Displaying sentiment data:

[0390] The server analyzes the emotional data collected from multiple users and presents the overall emotional trends of the team to the administrator. This allows the administrator to understand the emotional state of the entire team and take necessary actions. For example, if many team members are experiencing stress, this information is provided to the administrator, and countermeasures are suggested.

[0391] Specific example

[0392] Example 1:

[0393] A user creates a task called "Design Project A" and sets the deadline to November 30, 2023. If progress starts to fall behind, the server detects this and notifies the user. At the same time, if the emotion engine determines that the user's stress level is high, it also makes suggestions for stress reduction.

[0394] Example 2:

[0395] In projects involving multiple team members, if overall progress is behind schedule, the server uses an emotion engine to analyze the emotional state of all team members. It then provides the results to the administrator and suggests appropriate actions.

[0396] Example of a prompt

[0397] "Create a design task for Project A and set the deadline to November 30, 2023."

[0398] "Please update the progress of the design task for Project A to 50%."

[0399] "Please show the progress of all tasks."

[0400] "Please check for any progress risks in tasks with approaching deadlines, and notify us if any risks exist."

[0401] "Determine the user's emotional state based on their activity history."

[0402] "Please create a notification for when a user's stress level is high."

[0403] "Analyze the emotional state of the entire team and notify the manager."

[0404] Thus, the system of the present invention, in addition to conventional task management functions, utilizes an emotion engine to manage tasks while taking into account the user's emotional state, thereby improving operational efficiency and user satisfaction.

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

[0406] Step 1:

[0407] The user enters the task details.

[0408] Input: The user enters details such as the task name "Design Project A," deadline, and description into the task creation form on their device.

[0409] Operation: When the user clicks the input button, the form data on the device is retrieved.

[0410] Output: The retrieved data is ready to be converted to JSON format.

[0411] Step 2:

[0412] The terminal converts the task details into JSON format.

[0413] Input: Task details entered by the user.

[0414] Operation: The terminal generates JSON data like the following.

[0415] json

[0416] {

[0417] "Task name": "Design for Project A",

[0418] "Deadline": "2023-11-30",

[0419] "Description": "Creating design documents"

[0420] }

[0421] Output: Task details data converted to JSON format.

[0422] Step 3:

[0423] The device sends data in JSON format to the server.

[0424] Input: Task details data converted to JSON format.

[0425] Operation: The terminal sends data to the server as an HTTP POST request.

[0426] Output: JSON data sent to the server.

[0427] Step 4:

[0428] The server receives task details data and saves it to the database.

[0429] Input: JSON data sent from the device.

[0430] Operation: The server parses the received data and saves it to the database as a new task. The server generates a task ID and adds it to the database.

[0431] Output: New task information saved in the database.

[0432] Step 5:

[0433] The server notifies that the task has been created.

[0434] Input: New task information stored in the database.

[0435] Action: The server generates a response indicating that the task was successfully created and sends it back to the terminal.

[0436] Output: A task creation completion notification is displayed on the device.

[0437] Step 6:

[0438] The user enters the progress status of existing tasks.

[0439] Input: The user enters "Project A design task progress: 50%" into the progress update form on the device.

[0440] Operation: When the user clicks the progress update button, the form data is retrieved.

[0441] Output: The retrieved progress information is ready to be converted to JSON format.

[0442] Step 7:

[0443] The device converts the progress information into JSON format.

[0444] Input: Progress information entered by the user.

[0445] Operation: The terminal generates JSON data like the following.

[0446] json

[0447] {

[0448] "Task ID": "123",

[0449] "Progress Status": "50%"

[0450] }

[0451] Output: Progress information converted to JSON format.

[0452] Step 8:

[0453] The device sends progress information data in JSON format to the server.

[0454] Input: Progress information converted to JSON format.

[0455] Operation: The terminal sends data to the server as an HTTP PUT request.

[0456] Output: JSON data sent to the server.

[0457] Step 9:

[0458] The server receives progress information and updates the database.

[0459] Input: JSON data sent from the device.

[0460] Operation: The server parses the received progress information and updates the progress status of the corresponding task in the database.

[0461] Output: Progress information of tasks updated in the database.

[0462] Step 10:

[0463] The server notifies you that the progress update is complete.

[0464] Input: Progress information of tasks updated in the database.

[0465] Operation: The server generates a response indicating that the progress has been successfully updated and sends it back to the terminal.

[0466] Output: A progress update completion notification is displayed on the device.

[0467] Step 11:

[0468] The user requests an update on the progress of all tasks.

[0469] Input: User request.

[0470] Action: The user clicks the progress check button on the device.

[0471] Output: A progress request is sent to the server.

[0472] Step 12:

[0473] The server retrieves the progress of all tasks and returns it in JSON format.

[0474] Input: Progress request from the user.

[0475] Operation: The server retrieves all task information from the database and generates JSON data like the following.

[0476] json

[0477] [

[0478] {

[0479] "Task name": "Design for Project A",

[0480] "Progress Status": "50%"

[0481] "Deadline": "2023-11-30"

[0482] },

[0483] {

[0484] "Task name": "Development of Project B",

[0485] "Progress Status": "80%"

[0486] "Deadline": "2023-12-15"

[0487] }

[0488] ]

[0489] Output: JSON data containing the progress of all tasks.

[0490] Step 13:

[0491] The device receives and visualizes progress data in JSON format.

[0492] Input: JSON data received from the server.

[0493] Operation: The device analyzes the received data and displays it in a Gantt chart or calendar format.

[0494] Output: Visualized task progress displayed on the terminal.

[0495] Step 14:

[0496] The server periodically retrieves progress information for all tasks and assesses the risks.

[0497] Input: Progress information for all tasks stored in the database.

[0498] Operation: The server periodically scans the database to compare the progress and deadlines of each task.

[0499] Output: Results of risk task identification.

[0500] Step 15:

[0501] The server notifies the responsible person of the risky task.

[0502] Input: Task information with identified risks.

[0503] Operation: The server notifies the responsible person of the risk of delay via email or push notification.

[0504] Output: Notification sent to the person in charge.

[0505] Step 16:

[0506] The server collects user emotion data and analyzes it using an emotion engine.

[0507] Input: User input data and operation history.

[0508] Operation: The server passes the collected data to the sentiment engine, which then analyzes it using a machine learning model.

[0509] Output: Analysis results of the user's emotional state.

[0510] Step 17:

[0511] The server generates notifications based on emotional state.

[0512] Input: User's emotional state analysis results.

[0513] Operation: Based on the analysis results, the server generates appropriate notifications for the user. For example, if the user is experiencing high stress levels, it will suggest ways to relax.

[0514] Output: Notifications based on emotional state.

[0515] Step 18:

[0516] The server analyzes emotional data and provides the administrator with an overview of the team's overall emotional trends.

[0517] Input: Sentiment data from multiple users.

[0518] Operation: The server analyzes emotional data and generates data that visually displays the team's stress levels, satisfaction levels, and other metrics.

[0519] Output: Team-wide sentiment trend report for administrators.

[0520] Through the above processing steps, the task management system takes into account the user's emotional state, enabling efficient and highly satisfying task management.

[0521] (Application Example 2)

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

[0523] In factory task management, it is necessary not only to efficiently manage task progress but also to incorporate the recognition of workers' emotions to reduce stress and fatigue. Many conventional task management systems focus on progress and deadlines, failing to consider the emotional state of workers. This can lead to accumulated stress and fatigue, potentially resulting in decreased work efficiency and increased errors. Furthermore, the lack of a method to understand the emotional dynamics of the entire team makes it difficult for managers to take appropriate measures. To address these challenges, a comprehensive task management system that incorporates emotion recognition is necessary.

[0524] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying delays in task progress, means for performing emotion recognition based on operator status information, and means for providing notifications and suggestions based on the results of emotion recognition. This makes it possible to integrate task progress management and operator emotion management. In addition to checking progress and detecting delays early, it is possible to recognize the operator's stress level and take appropriate measures, which is expected to improve work efficiency and reduce errors. Furthermore, by displaying the emotional trends of the entire team, managers can take countermeasures at the appropriate time. This can improve overall work efficiency and operator satisfaction.

[0525] "Task creation" refers to the process where a user inputs new work content and its details into the system, and the system generates a new work item based on that input.

[0526] "Task updating" refers to the process where a user inputs the content and progress of already created work items, and the system then modifies or adds information to the corresponding work items based on that input.

[0527] "Visualization of progress" means that the system displays the progress status of current work items in a format that allows for visual confirmation (e.g., Gantt chart or calendar format).

[0528] "Detection of progress delays" means that the system automatically determines whether a work item is behind schedule.

[0529] "Notification" refers to the system informing users of progress delays or important information via methods such as email or push notifications.

[0530] "Operator status information" refers to information that the worker inputs into the system, such as their work environment, work content, actions, and voice.

[0531] "Emotion recognition" refers to a system analyzing and determining an operator's emotional state based on their voice, actions, and other factors.

[0532] "Notifications and suggestions" refer to the system providing necessary warnings and action suggestions to the operator based on the results of emotion recognition.

[0533] A "generative AI model" refers to artificial intelligence that uses algorithms and networks trained through machine learning to analyze and generate emotional states and other information based on input data.

[0534] An "operator" is a user who uses a system to perform tasks.

[0535] "Team-wide emotional trends" refers to the trend in the overall emotional state of the team, obtained by analyzing emotional data collected from multiple operators.

[0536] The present invention is a task management system that integrates emotion recognition and performs comprehensive task management that takes into account the emotional state of the operator. This system includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of the risk of progress delays, means for performing emotion recognition based on the operator's status information, and means for making notifications and suggestions based on the results of emotion recognition.

[0537] Hardware and software to be used

[0538] The system configuration includes the following hardware and software:

[0539] Hardware: Industrial robots (e.g., robotic arms), smart displays, audio input devices, microphones.

[0540] Software: Python programs, EmotionEngine module, emotion recognition module, task management server API.

[0541] Overview of program processing

[0542] Task creation and update

[0543] The user inputs new work details into the robot within the factory, converts the information into JSON format, and sends it to the task management server. The server stores the task information in a database and generates new tasks. The progress of the created tasks is updated when the user inputs the information through the robot and sends it to the server.

[0544] Task visualization

[0545] Users can check the progress of tasks in real time via devices such as smart displays. All task information is received from the server in JSON format and visually displayed in Gantt charts and calendar formats.

[0546] Risk notification

[0547] The server periodically retrieves task progress information from the database and determines the risk of delays. The determined risk is communicated to the user through various means, including email and push notifications.

[0548] emotion recognition

[0549] An emotion recognition module is used to recognize the emotional state of the operator from their voice and actions while they perform their tasks. The EmotionEngine module analyzes the voice data collected by the robot and evaluates stress levels and satisfaction levels.

[0550] Emotion-based notifications and suggestions

[0551] Based on the assessed emotional state, the system provides the operator with appropriate notifications and suggestions. If the emotional recognition results indicate a high stress level, for example, a suggestion such as "Please take a break" will be sent via the robot.

[0552] Displaying sentiment data

[0553] Emotional data is analyzed on the server, and a function is provided to display the emotional trends of the entire team. This allows administrators to understand the team's emotional state and take appropriate measures.

[0554] Specific example

[0555] 1. Specific examples of creating and updating tasks:

[0556] An operator voice-inputs the task "factory machine maintenance" into the robot and sets the deadline as November 30, 2023. This information is converted to JSON format and sent to the server to generate a new task. When the task progress reaches 50%, the operator inputs the progress into the robot, and the updated information is sent to the server.

[0557] 2. Specific examples of emotion recognition and notification:

[0558] If an operator says "I'm tired" during work, the robot collects the audio, and an emotion recognition module evaluates the stress level. If the evaluation is high, the robot notifies the operator to "take a break."

[0559] 3. Specific examples of emotional data analysis:

[0560] The server analyzes emotional data collected from multiple operators and displays a result to the administrator indicating that "the team's stress level is high." The administrator then takes action based on this result.

[0561] Examples of prompts to input into a generative AI model:

[0562] "Please create a notification message for when a task is behind schedule."

[0563] "Generate suggestions for operators based on emotion recognition."

[0564] "Please generate a report showing the overall sentiment trends of the team."

[0565] This system integrates task progress management with worker emotional management, thereby improving work efficiency and overall satisfaction within the factory.

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

[0567] Step 1: Create a task

[0568] The user provides voice input to the robot specifying the details of a new task and its deadline. The robot converts this information into text and formats it into JSON format. For example, the input data might be "Task Name: 'Factory Machine Maintenance', Deadline: '2023-11-30'". The JSON data is sent to the server, which stores this data in its database and generates a new task.

[0569] Step 2: Update the task

[0570] The user inputs the work progress into the robot via voice. The robot converts this progress information into text and then formats it back into JSON format. The input data is, for example, "Task ID: '123', Progress: '50%'". The data converted to JSON format is sent to the server, which updates the database with information about the corresponding task.

[0571] Step 3: Visualize the task

[0572] The user sends a request from their device to the server to check the progress of their tasks. The server retrieves information on all tasks from the database and sends it back to the device in JSON format. The device parses the received data and displays it in a Gantt chart or calendar format.

[0573] Step 4: Detecting progress delays

[0574] The server periodically retrieves task progress information from the database and determines if there are any delays compared to the deadline. For comparison, data such as "Task ID: '123', Current Progress: '50%', Deadline: '2023-11-30'" is used. Tasks that are behind schedule are identified, and the server notifies the user of the delay risk.

[0575] Step 5: Emotion Recognition

[0576] An operator provides voice input to the robot while performing a task. The robot collects this voice data and sends it to an emotion recognition module. The emotion recognition module analyzes the voice data and determines the emotional state. An example of the input data is "audio data: 'audio_sample.wav'". The determined emotional state is output as a numerical value, such as a stress level.

[0577] Step 6: Emotion-based notifications and suggestions

[0578] Based on the emotional state data received from the emotion recognition module, the server generates necessary notifications and suggestions for the operator. If the emotional data indicates a "high stress level," the server notifies the operator to "take a break." Specific notification content, such as "recommendation to take a break," is generated, and the robot communicates this information to the operator via voice.

[0579] Step 7: Displaying emotion data

[0580] The server analyzes emotional data collected from multiple operators to visualize the emotional trends of the entire team. The analyzed data is sent to terminals and displayed on smart displays, etc. For example, the displayed content might be "Team-wide stress level: 'High'". This allows administrators to understand the emotional state of the entire team.

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

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

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

[0584] [Second Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0597] This invention is a system that manages tasks created and updated by users, visualizes the progress of tasks, detects delay risks, and provides timely notifications. The implementation of this system is described below.

[0598] Task creation and update

[0599] When a user creates a task, they first enter the task details (task name, due date, assignee, dependent tasks, etc.) from their device. The device then sends this information to the task management server in JSON format. The server saves the received data to its database, and a new task is created. For example, a user can create a task called "Design Project X" and set its due date to October 10, 2023.

[0600] When a user updates the progress of a task, they enter the current progress percentage (e.g., 50%) from their terminal and send it to the server. The server updates the progress data in the database and reflects the information in other tasks related to that task. For example, a user can set the progress of "Design Project X" to 50%.

[0601] Task visualization

[0602] To check the progress of tasks, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device visualizes the retrieved task information in a format such as a Gantt chart or calendar. This makes it easier for the user to see the progress of all tasks at a glance. For example, the progress of "Project X Design" is displayed as 50% on the Gantt chart.

[0603] Risk notification

[0604] To detect the risk of tasks falling behind schedule, the server periodically monitors the progress of all tasks. The server compares the progress of tasks with their deadlines to identify tasks that are at risk of not meeting their deadlines. This risk assessment is based on the remaining time and the required progress. For example, if task "Development of Project Y" is 20% complete and its deadline is November 1, 2023, the server will determine that this task is behind schedule.

[0605] If a delay risk is detected, the server sends a notification to the person in charge of the relevant task via email or push notification. This allows the person in charge to take immediate action. For example, the server sends a notification to the person in charge of "Development of Project Y" stating, "Task 'Development of Project Y' is likely to be delayed."

[0606] These features allow users to eliminate wasted time on progress checks, manage tasks efficiently, and detect and address risks early. The system of this invention automates, visualizes, and provides timely notifications for task management, thereby improving operational efficiency and avoiding risks.

[0607] The following describes the processing flow.

[0608] Task creation and update

[0609] Task creation

[0610] Step 1:

[0611] The user enters task details (task name, due date, assignee, dependent tasks, etc.) on their device. This information is entered as a form.

[0612] Step 2:

[0613] The terminal converts the entered task information into JSON format and sends a POST request to the task management server.

[0614] Step 3:

[0615] The server parses the received request and extracts task information.

[0616] Step 4:

[0617] The server saves task information to the database. A task ID is also issued for newly created tasks.

[0618] Step 5:

[0619] The server verifies that the task was created successfully and returns a success message to the terminal.

[0620] Task update

[0621] Step 1:

[0622] To update the progress, the user enters the task's progress percentage (e.g., 50%) on their device.

[0623] Step 2:

[0624] The terminal converts the update information into JSON format and sends a PUT request to the task management server.

[0625] Step 3:

[0626] The server parses the received request and extracts the target task ID and the updated progress information.

[0627] Step 4:

[0628] The server updates the progress information of the relevant task in the database.

[0629] Step 5:

[0630] The server confirms that the task progress has been successfully updated and returns a success message to the terminal.

[0631] Task visualization

[0632] Step 1:

[0633] To check the progress of all tasks, the user requests task information on their device. This is sent as a GET request to the server.

[0634] Step 2:

[0635] The server retrieves progress information for all tasks from the database.

[0636] Step 3:

[0637] The server converts the acquired task information into JSON format and sends it back to the terminal.

[0638] Step 4:

[0639] The terminal analyzes the received task information and displays it to the user in a Gantt chart or calendar format.

[0640] Risk notification

[0641] Step 1:

[0642] The server periodically retrieves progress information for all tasks from the database and compares it with the task deadlines.

[0643] Step 2:

[0644] The server compares progress with deadlines and identifies tasks that may not be completed by the deadline.

[0645] Step 3:

[0646] The server retrieves the information of the person responsible for the identified risk task and generates a notification indicating a risk of delay.

[0647] Step 4:

[0648] The server sends the generated notification content to the responsible person's terminal via email or push notification.

[0649] Step 5:

[0650] The device displays received notifications to the user and informs them about the risk of delays.

[0651] (Example 1)

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

[0653] Traditional task management systems had problems with efficiently creating and updating tasks, visualizing progress, and notifying users of delay risks. In particular, when multiple tasks were dependent on each other or in large-scale projects, it was difficult to grasp progress in real time and detect delay risks early, which raised concerns about a decrease in overall work efficiency.

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

[0655] In this invention, the server includes means for the user to input detailed task information, means for transmitting the input information to the server, means for the server to store the received information in a database, means for the user to update the task progress, means for transmitting the progress data to the server, means for the server to update the database with the received progress data, means for the user to send a request to retrieve task information, means for the server to retrieve all task information from the database and send it back to the terminal, means for the terminal to visualize the received task information, means for the server to periodically monitor the task progress and evaluate the risk of delay, and means for notifying the evaluation results. This enables real-time task management and visualization of progress, as well as rapid detection and notification of delay risks.

[0656] A "user" refers to an individual or legal entity that uses the system to create tasks, update their progress, or check their progress.

[0657] A "terminal" refers to an electronic device used by a user to input information or display data from a server.

[0658] A "server" refers to a computing system used for managing task information, storing data, monitoring progress, and providing notifications.

[0659] A "database" refers to an information management system used by a server to store task information and progress data.

[0660] A "task" refers to a series of actions or activities that a user creates to achieve a specific objective.

[0661] "Progress status" refers to information indicating the extent to which a task has been completed.

[0662] "Visualization" refers to the process of displaying the progress of a task in an easy-to-understand way for the user.

[0663] "Risk" refers to a situation where the progress of a task may fall behind schedule.

[0664] "Notification" refers to a means of communication used by a server to inform the person in charge of a task about the risk of delays.

[0665] "JSON format" is an abbreviation for JavaScript Object Notation, and refers to a lightweight data exchange format for structurally representing data.

[0666] This invention provides a system for efficiently managing user-created and updated tasks, visualizing progress, and detecting and notifying users of delay risks at an early stage. The configuration for implementing this system is described below.

[0667] Task creation and update

[0668] The user first enters task details (task name, due date, assignee, dependent tasks, etc.) into the terminal. This information is converted to JSON format and sent to the task management server. The server saves the received data to its database, and a new task is created. For example, a user might create a task called "Design Project X" and set the due date to October 10, 2023. When the user updates the task's progress, they enter the progress percentage (e.g., 50%) from the terminal and send it to the server. The server saves the received progress data to its database and reflects the information in other tasks related to that task. For example, a user might set the progress of "Design Project X" to 50%.

[0669] Task visualization

[0670] To check the progress of a task, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device visualizes the retrieved task information in a format such as a Gantt chart or calendar, allowing the user to see the progress of all tasks at a glance. For example, the progress of "Project X Design" may be displayed as 50% on the Gantt chart.

[0671] Risk notification

[0672] The server periodically monitors the progress of all tasks, comparing progress with deadlines to assess the risk of delay. This assessment is based on the remaining time and required progress, and if there is a risk of delay, the server sends a notification to the person in charge of the task via email or push notification. For example, if task "Development of Project Y" is 20% complete and due on November 1, 2023, the server will determine that this task is behind schedule and send a notification to the person in charge stating, "Task 'Development of Project Y' is likely to be delayed."

[0673] These features allow users to eliminate wasted time on progress checks, manage tasks efficiently, and detect and address risks early. The system of this invention automates, visualizes, and provides timely notifications for task management, thereby improving operational efficiency and avoiding risks.

[0674] Command example

[0675] By using a generative AI model, you can receive explanations and help for each function by entering prompts like the following.

[0676] Examples of prompts for a generative AI model:

[0677] Please explain each function of the following task management system in clear, natural language.

[0678] Task creation and update

[0679] When a user creates a task, they enter the task details (task name, due date, assignee, dependent tasks, etc.) from their device. The device sends this information to the task management server in JSON format. The server saves the received data to its database, and a new task is created.

[0680] Example: A user creates a task called "Design Project X" and sets the deadline to October 10, 2023.

[0681] When a user updates the progress of a task, they enter the current progress percentage (e.g., 50%) from their device and send it to the server. The server updates the progress data in the database and reflects the information in other tasks related to that task.

[0682] Specific example: The user sets the progress of "Project X Design" to 50%.

[0683] Task visualization

[0684] To check the progress of their tasks, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device then visualizes the retrieved task information in a format such as a Gantt chart or calendar.

[0685] Specific example: The progress of "Project X Design" is displayed as 50% on the Gantt chart.

[0686] Risk notification

[0687] The server periodically monitors the progress of all tasks to detect the risk of tasks falling behind schedule. The server compares task progress with deadlines to identify tasks at risk of missing deadlines. This risk assessment is based on the remaining time and the required progress.

[0688] Specific example: If task "Development of Project Y" is 20% complete and due on November 1, 2023, the server will determine that this task is behind schedule.

[0689] If a delay risk is detected, the server will send a notification to the person responsible for the relevant task via email or push notification.

[0690] Specific example: The server sends a notification to the person in charge of "Development of Project Y" stating, "Task 'Development of Project Y' is likely to be delayed."

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

[0692] Step 1:

[0693] The user enters the task details.

[0694] The user uses their device to enter details about the new task (task name, due date, assignee, dependent tasks, etc.).

[0695] Input: User-entered task name "Project X Design", deadline "October 10, 2023", assignee "Taro Yamada", dependent task "Project W Review", etc.

[0696] Data processing: The terminal converts the entered information into JSON format.

[0697] Output: Task information in JSON format: "{'taskName': 'Project X Design', 'deadline': '2023-10-10', 'assignee': 'Taro Yamada', 'dependency': 'Project W Review'}".

[0698] Step 2:

[0699] The device sends task data to the server.

[0700] The terminal sends the converted JSON-formatted task information to the task management server.

[0701] Input: Task information in JSON format.

[0702] Data processing: None (simple data transfer).

[0703] Output: Task information sent to the server.

[0704] Step 3:

[0705] The server saves the task information it receives to the database.

[0706] The server saves the received task information to the database and registers it as a new task.

[0707] Input: Received task information in JSON format.

[0708] Data processing: Convert the data to a format suitable for the database and save it as a new record in the database.

[0709] Output: A new task record added to the database.

[0710] Step 4:

[0711] The user enters the task progress.

[0712] The user uses their device to input the progress of an existing task (e.g., 50%).

[0713] Input: User-entered task name "Project X Design", progress "50%".

[0714] Data processing: The terminal converts the entered information into JSON format.

[0715] Output: Progress information in JSON format: "{'taskName': 'Project X Design', 'progress': 50}".

[0716] Step 5:

[0717] The device sends progress data to the server.

[0718] The terminal sends the converted JSON-formatted progress information to the task management server.

[0719] Input: Progress information in JSON format.

[0720] Data processing: None (simple data transfer).

[0721] Output: Progress information sent to the server.

[0722] Step 6:

[0723] The server updates the database with progress information.

[0724] The server saves the received progress information to the database and updates the progress status of the relevant task. It also reflects the information in other tasks related to that task.

[0725] Input: Received progress information in JSON format.

[0726] Data processing: Update the progress of the relevant task in the database. Also update related tasks.

[0727] Output: Updated task records in the database.

[0728] Step 7:

[0729] A user submits a request to retrieve task information.

[0730] The user uses their terminal to send a request to the server to retrieve information about all tasks.

[0731] Input: Task information retrieval request.

[0732] Data processing: None (simple request).

[0733] Output: The request sent to the server.

[0734] Step 8:

[0735] The server retrieves task information from the database.

[0736] The server retrieves information on all tasks from the database and converts it to JSON format.

[0737] Input: Task information retrieval request.

[0738] Data processing: Execute database queries to retrieve task information and convert it to JSON format.

[0739] Output: Task information in JSON format.

[0740] Step 9:

[0741] The server sends task information back to the terminal.

[0742] The server returns the converted task information in JSON format to the terminal.

[0743] Input: Task information in JSON format.

[0744] Data processing: None (simple data transfer).

[0745] Output: Task information sent to the terminal.

[0746] Step 10:

[0747] The device visualizes task information.

[0748] The device uses the received task information to visualize it in a Gantt chart or calendar format.

[0749] Input: Received task information in JSON format.

[0750] Data processing: Convert task information into Gantt charts and calendar formats.

[0751] Output: Displayed task information (e.g., "Project X Design" progress: 50%).

[0752] Step 11:

[0753] The server monitors the progress of the task.

[0754] The server periodically retrieves the progress of all tasks from the database, compares the progress with the deadline, and assesses the risk of delays.

[0755] Input: All task information in the database.

[0756] Data processing: Compare progress with deadlines and assess the risk of delays.

[0757] Output: Delay risk assessment results.

[0758] Step 12:

[0759] The server will notify you of the risk of delay.

[0760] The server sends notifications via email or push notification to the person responsible for the task where a delay risk has been identified.

[0761] Input: Delay risk assessment results.

[0762] Data processing: Generate and send a notification message.

[0763] Output: Notification sent to the person in charge (e.g., "Task 'Development of Project Y' is likely to be delayed.").

[0764] (Application Example 1)

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

[0766] Traditional task management systems required users to use desktop or mobile devices to create tasks, update progress, and receive notifications about delay risks, resulting in cumbersome manual data entry. Furthermore, they often lacked real-time visualization of progress and risk notifications, making quick responses difficult.

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

[0768] In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of delays in task progress, means for inputting tasks and updating their progress using smart glasses, means for visualizing the progress displayed on the smart glasses, and means for notifying the smart glasses of delay risks. This enables users to manage tasks hands-free, check progress and risks in real time, and take quick countermeasures.

[0769] "Means for creating and updating tasks" refers to a function that allows users to input new tasks and send detailed information about those tasks to the server for storage in the database.

[0770] "Means of visualizing task progress" refers to a function where the server retrieves task information from a database and displays it in a format that is easy for the user to understand visually.

[0771] "A means of detecting and notifying about delays in task progress" refers to a function in which the server compares the progress and deadline of a task, identifies tasks at risk of delay, and notifies the user of that information.

[0772] "A means of inputting tasks and updating progress using smart glasses" refers to a function that allows users to input detailed task information and progress using voice commands or gestures through smart glasses, and to send that information to a server.

[0773] "Means of visualizing progress displayed on smart glasses" refers to a function that displays the progress of tasks on the smart glasses' screen in the form of a Gantt chart or calendar.

[0774] "A means of providing delay risk notifications to smart glasses" refers to a function that displays delay risk notifications sent from the server on smart glasses, enabling users to respond quickly.

[0775] Modes for carrying out the invention

[0776] This invention is a system that manages tasks created and updated by users, visualizes the progress of tasks, detects delay risks, and provides timely notifications. Specific embodiments thereof are described below.

[0777] Task creation and update

[0778] When a user creates a task, they input task details (task name, due date, assignee, dependent tasks, etc.) into the smart glasses using voice commands or gestures. The smart glasses send this information to the task management server in JSON format, and the server stores the received data in its database and creates a new task. For example, a user can create a task called "Design a New Project" and set the due date to a specific date.

[0779] To update task progress, the user similarly inputs the current progress level into their smart glasses using voice commands or gestures and sends it to the server. The server updates the progress data in its database and reflects the information in other tasks related to that task. For example, a user can set the progress of "Design a New Project" to 50%.

[0780] Task visualization

[0781] To check the progress of tasks, the user sends a request to the server via smart glasses to retrieve all tasks. The server retrieves task information from the database and returns it to the smart glasses in JSON format. The progress of tasks is displayed on the smart glasses' screen in the form of a Gantt chart or calendar. This makes it easy for the user to see the progress of all tasks at a glance. For example, the progress of "Designing a New Project" is displayed on the Gantt chart.

[0782] Risk notification

[0783] To detect the risk of tasks falling behind schedule, the server periodically monitors the progress of all tasks. The server compares the progress of tasks with their deadlines to identify tasks that are at risk of not being met. This risk assessment is based on the remaining time and the required progress. For example, if a task is 20% complete and has a deadline of a specific date, the server will determine that this task is behind schedule.

[0784] If a delay risk is detected, the server sends a push notification to the smart glasses, displaying the notification to the person responsible for the relevant task. This allows the person responsible to take immediate action. For example, the server might send a notification to the person responsible for "Designing a New Project" stating, "This task is likely to be delayed."

[0785] Specific example

[0786] For example, consider a task management scenario in a factory. The user (worker) wears smart glasses and inputs the next task using voice or gestures. The worker can create a new task, such as "check the assembly line," and update its progress in real time. The server monitors the task's progress and sends a notification to the smart glasses if the progress is behind schedule despite the approaching deadline, alerting the user to the risk.

[0787] Example of a prompt

[0788] Please enter the task details. Include the task name, due date, assignee, and dependent tasks.

[0789] This system allows users to manage tasks effortlessly and perform their work efficiently. It also enables early detection of risks and prompt action.

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

[0791] Step 1:

[0792] The user inputs task details into smart glasses using voice commands or gestures. This includes information such as the task name, due date, assignee, and dependent tasks. The smart glasses convert this information into JSON format and send it to the task management server.

[0793] Input: Enter task details (task name, due date, assignee, dependent tasks) using voice or gestures.

[0794] Processing: Smart glasses analyze voice or gestures and convert them into JSON format.

[0795] Output: Task information converted to JSON format is sent to the server.

[0796] Step 2:

[0797] The server saves the received task information to the database and creates a new task. The server parses the JSON data and writes it to the database in the appropriate format.

[0798] Input: Task information in JSON format.

[0799] Processing: The server parses the JSON and saves it to the database.

[0800] Output: A new task is added to the database.

[0801] Step 3:

[0802] The user updates task progress via smart glasses. Progress is entered via voice or gestures, and the smart glasses convert this into JSON format and send it to the server.

[0803] Input: Enter the progress percentage (e.g., 50%) using voice or gestures.

[0804] Processing: The smart glasses analyze the input and convert it to JSON format.

[0805] Output: Sends progress information in JSON format to the server.

[0806] Step 4:

[0807] The server updates the database with the received progress information, and the progress is reflected in the relevant task and related tasks. The server analyzes the progress information and updates the progress of the relevant task.

[0808] Input: Progress information in JSON format.

[0809] Processing: The server parses the JSON and updates the progress of the corresponding task in the database.

[0810] Output: Task information in the database is updated.

[0811] Step 5:

[0812] The user uses smart glasses to check the progress of all tasks. A request to retrieve all tasks is sent from the smart glasses to the server.

[0813] Input: A request to check the progress of all tasks.

[0814] Processing: The server retrieves task information from the database and sends it back to the smart glasses in JSON format.

[0815] Output: Task information in JSON format is sent to the smart glasses.

[0816] Step 6:

[0817] The smart glasses display received task information in Gantt chart and calendar formats. This allows users to check the progress of all tasks hands-free.

[0818] Input: Task information in JSON format.

[0819] Processing: Smart glasses parse the JSON data and convert it into a Gantt chart or calendar for display.

[0820] Output: Visualized task progress is displayed on the smart glasses' screen.

[0821] Step 7:

[0822] The server periodically monitors the progress of tasks and detects tasks at risk of delay. The server compares the progress with the deadline to make a determination.

[0823] Input: Task progress information and deadline information from the database.

[0824] Processing: The server compares progress and deadlines to identify tasks at risk of delay.

[0825] Output: Delay risk assessment result.

[0826] Step 8:

[0827] When a delay risk is detected, the server sends a push notification to the smart glasses, displaying the notification to the person responsible for the relevant task. This allows the user to take immediate action.

[0828] Input: Delay risk assessment result.

[0829] Processing: The server generates a push notification and sends it to the smart glasses.

[0830] Output: A delay risk notification is displayed on the smart glasses.

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

[0832] This invention provides a more efficient and satisfying work environment by combining a task management system with an emotion engine, enabling notifications and task management based on the user's emotions. This system includes means for creating and updating tasks, means for visualizing progress, means for detecting and notifying of delays in progress, and an emotion engine that recognizes the user's emotions.

[0833] Task creation and update

[0834] Task creation:

[0835] The user enters task details on their device. The device converts this information into JSON format and sends it to the task management server. The server stores the task information in its database and generates a new task.

[0836] Task update:

[0837] The user enters the progress status on the terminal, and the terminal converts this information into JSON format and sends it to the server. The server updates the progress information for the corresponding task in the database.

[0838] Task visualization

[0839] The user sends a request from their device to the server to check the progress of all tasks. The server retrieves information on all tasks from the database and sends it back to the device in JSON format. The device then parses the task information and displays it in a Gantt chart or calendar format.

[0840] Risk notification

[0841] The server periodically retrieves progress information for all tasks from the database and compares it with task deadlines. By comparing progress and deadlines, it identifies tasks that are likely to not be completed on time. Assignees of identified risk tasks are notified of the delay risk via email or push notification.

[0842] Emotional Engine

[0843] Emotion recognition:

[0844] The server analyzes user input data, operation history, and other relevant data to recognize the user's emotions. The emotion engine uses machine learning models to determine the user's emotional state (e.g., stress, satisfaction, anxiety). Information as the user enters or updates tasks is also sent to the emotion engine and used for analysis.

[0845] Emotion-based notifications:

[0846] The emotion engine analyzes the user's emotional state and generates notifications tailored to that specific emotional state. For example, if the user is feeling stressed, the server will notify them with a suggestion to "relax." Similarly, if there is a high risk of delays, the server will provide a notification that takes the user's emotional state into consideration.

[0847] Displaying sentiment data:

[0848] The server also analyzes emotional data collected from multiple users and provides a function to display the emotional trends of the entire team. This allows administrators to understand the emotional state of the entire team and take necessary actions. For example, if many team members are experiencing stress, the server will provide this information to the administrator and suggest countermeasures.

[0849] Specific example

[0850] Example 1:

[0851] A user creates a task called "Design Project A" and sets the deadline to November 30, 2023. If progress starts to fall behind, the server detects this and notifies the user. At the same time, if the emotion engine determines that the user's stress level is high, it also makes suggestions for stress reduction.

[0852] Example 2:

[0853] In projects involving multiple team members, if overall progress is behind schedule, the server uses an emotion engine to analyze the emotional state of all team members. It then provides the results to the administrator and suggests appropriate actions.

[0854] These features allow the task management system to not only manage task progress but also contribute to managing user emotions, thereby improving overall work efficiency and user satisfaction. The system of this invention realizes a more human-centered task management environment by taking user emotions into consideration.

[0855] The following describes the processing flow.

[0856] Task creation and update

[0857] Task creation

[0858] Step 1:

[0859] The user enters details of a new task on their device. Specifically, they use a form to enter items such as the task name, due date, assignee, and dependent tasks.

[0860] Step 2:

[0861] The terminal converts the entered task information into JSON format and sends a POST request to the task management server.

[0862] Step 3:

[0863] The server parses the received request and extracts task information.

[0864] Step 4:

[0865] The server saves task information to the database. At the same time, it generates an ID for the newly created task.

[0866] Step 5:

[0867] The server confirms that the task was created successfully and sends a success message and a new task ID back to the terminal.

[0868] Task update

[0869] Step 1:

[0870] Users update the task progress by entering the progress percentage (e.g., 50%) on their device. Use an update form or interactive element.

[0871] Step 2:

[0872] The terminal converts the progress information into JSON format and sends a PUT request to the task management server.

[0873] Step 3:

[0874] The server analyzes the received request and extracts the target task ID and progress information.

[0875] Step 4:

[0876] The server updates the progress information of the relevant task in the database.

[0877] Step 5:

[0878] The server confirms that the task progress has been successfully updated and sends a success message back to the terminal.

[0879] Task visualization

[0880] Step 1:

[0881] To check the progress of all tasks, the user requests task information on their device. This is sent as a GET request to the server.

[0882] Step 2:

[0883] The server retrieves progress information for all tasks from the database.

[0884] Step 3:

[0885] The server converts the acquired task information into JSON format and sends it back to the terminal.

[0886] Step 4:

[0887] The terminal analyzes the received task information and displays it to the user in a Gantt chart or calendar format.

[0888] Risk notification

[0889] Step 1:

[0890] The server periodically retrieves progress information for all tasks from the database and compares it with the task deadlines.

[0891] Step 2:

[0892] The server compares progress with deadlines and identifies tasks that may not be completed by the deadline.

[0893] Step 3:

[0894] The server retrieves the information of the person responsible for the identified risk task and generates a notification indicating a risk of delay.

[0895] Step 4:

[0896] The server sends the generated notification content to the responsible person's terminal via email or push notification.

[0897] Step 5:

[0898] The device displays received notifications to the user and informs them about the risk of delays.

[0899] Emotional Engine

[0900] Step 1:

[0901] The server periodically collects user input data and operation history, and analyzes it using an emotion engine.

[0902] Step 2:

[0903] The emotion engine uses machine learning models to determine the user's emotional state based on collected data. For example, it can identify stress levels, satisfaction levels, and so on.

[0904] Step 3:

[0905] When a user enters or updates a task, data from the device is sent to the sentiment engine and used for sentiment analysis.

[0906] Step 4:

[0907] The emotion engine generates appropriate notifications for the user based on the determined emotional state. For example, if the user is experiencing high stress, it will suggest relaxation techniques.

[0908] Step 5:

[0909] The server sends the generated notification content to the user's device via email or push notification.

[0910] Step 6:

[0911] The server analyzes the emotional data of multiple users and generates data to display the emotional trends of the entire team.

[0912] Step 7:

[0913] Administrators can monitor the emotional state of the entire team through their devices and take necessary measures. For example, if many members are experiencing high levels of stress, they can use that information to provide support.

[0914] (Example 2)

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

[0916] Traditional task management systems can track task progress and notify users of delays, but they lack the ability to consider users' emotional states, making efficient task management difficult. In particular, ignoring emotional factors such as user stress and satisfaction can hinder task progress. Furthermore, the lack of means for managers to understand the emotional dynamics of the entire team makes appropriate responses difficult.

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

[0918] In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of delays in task progress, means for recognizing user emotions and notifying based on the analysis results, and means for analyzing user and multiple user emotion data and presenting it to the administrator. This enables efficient and highly satisfying task management that takes into account the emotional state of users.

[0919] A "task" refers to a unit of work or task that a user performs to achieve a specific objective.

[0920] "Means" refers to the methods or mechanisms that a system uses to achieve a specific function.

[0921] A "server" refers to a computer system that provides or processes data in response to requests from clients.

[0922] A "terminal" refers to a device that a user uses to access and operate a system. Examples include personal computers, smartphones, and tablets.

[0923] "Users" refer to the people who use this system to create, update, and manage tasks.

[0924] "Means for creating and updating tasks" refers to a system that provides users with the functionality to create new tasks and modify information about existing tasks.

[0925] "Means of visualizing task progress" refers to a system that provides a function to visually display the progress of tasks. For example, it can be displayed in a Gantt chart or calendar format.

[0926] "Means for detecting and notifying about delays in task progress" refers to a system that compares the progress of a task with its deadline and provides a function to notify the user if there is a risk of delay.

[0927] "A means of recognizing user emotions and providing notifications based on the analysis results" refers to a system that analyzes user input data and operation history, recognizes the user's emotional state, and provides a function to generate notifications corresponding to specific emotional states.

[0928] "Means of analyzing and presenting emotional data of users or multiple users to administrators" refers to a system that provides functions for collecting and analyzing emotional data of users or entire teams and providing the results to administrators.

[0929] "Notification" refers to a means by which a system communicates information to a user. Specifically, this includes email and push notifications.

[0930] "Visualization" refers to the visual display of data and information. This includes, for example, displaying data using graphs and charts.

[0931] An "emotion engine" refers to a software component that includes a machine learning model for analyzing and recognizing a user's emotional state.

[0932] A "machine learning model" refers to an algorithm that learns from large amounts of data and uses that data to perform inferences and predictions.

[0933] This invention is a task management system that takes user emotions into consideration, and by providing means for creating and updating tasks, means for visualizing progress, means for detecting and notifying of progress delays, and an emotion engine, it provides an efficient and highly satisfying work environment.

[0934] Task creation and update

[0935] Task creation:

[0936] The user enters details such as the task name, due date, and description into a task creation form on their device. This detailed information is converted to JSON format by the device and sent to the server. The server parses the received JSON data and saves it as a new task in the database. For example, if a user creates a task called "Design Project A" and sets the due date to November 30, 2023, the device converts this information to JSON format and sends it to the server via an HTTP POST request.

[0937] Task update:

[0938] The user enters the progress status of an existing task (e.g., 50%) on their device. This information is also converted to JSON format by the device and sent to the server. The server reflects the received progress information in the corresponding task in the database and updates the progress status.

[0939] Task visualization

[0940] When a user sends a request from their device to check the progress of all tasks, the server retrieves information on all tasks from the database and sends it back in JSON format. The device then parses the received JSON data and displays it visually in a Gantt chart or calendar format. This allows the user to grasp the progress of each task at a glance.

[0941] Risk notification

[0942] The server periodically retrieves progress information for all tasks from the database and compares the progress with the deadline. If a task is found to be behind schedule, the server notifies the task's assignee of the delay risk via email or push notification. For example, if a task due on November 30, 2023, is less than 20% complete, it will be flagged as a risk task and the assignee will be notified.

[0943] Emotional Engine

[0944] Emotion recognition:

[0945] The server collects user input data and operation history, and uses an emotion engine to analyze the user's emotional state. The emotion engine uses machine learning models to determine the user's stress, satisfaction, and anxiety levels. For example, if the frequency of task updates is low and there are signs of anxiety in the operation history, the server will determine that the user's stress level is high.

[0946] Emotion-based notifications:

[0947] Based on the emotion engine's analysis of the user's emotional state, the server generates notifications tailored to that specific emotional state. For example, if the user is feeling stressed, it sends a notification suggesting a break to relax.

[0948] Displaying sentiment data:

[0949] The server analyzes the emotional data collected from multiple users and presents the overall emotional trends of the team to the administrator. This allows the administrator to understand the emotional state of the entire team and take necessary actions. For example, if many team members are experiencing stress, this information is provided to the administrator, and countermeasures are suggested.

[0950] Specific example

[0951] Example 1:

[0952] A user creates a task called "Design Project A" and sets the deadline to November 30, 2023. If progress starts to fall behind, the server detects this and notifies the user. At the same time, if the emotion engine determines that the user's stress level is high, it also makes suggestions for stress reduction.

[0953] Example 2:

[0954] In projects involving multiple team members, if overall progress is behind schedule, the server uses an emotion engine to analyze the emotional state of all team members. It then provides the results to the administrator and suggests appropriate actions.

[0955] Example of a prompt

[0956] "Create a design task for Project A and set the deadline to November 30, 2023."

[0957] "Please update the progress of the design task for Project A to 50%."

[0958] "Please show the progress of all tasks."

[0959] "Please check for any progress risks in tasks with approaching deadlines, and notify us if any risks exist."

[0960] "Determine the user's emotional state based on their activity history."

[0961] "Please create a notification for when a user's stress level is high."

[0962] "Analyze the emotional state of the entire team and notify the manager."

[0963] Thus, the system of the present invention, in addition to conventional task management functions, utilizes an emotion engine to manage tasks while taking into account the user's emotional state, thereby improving operational efficiency and user satisfaction.

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

[0965] Step 1:

[0966] The user enters the task details.

[0967] Input: The user enters details such as the task name "Design Project A," deadline, and description into the task creation form on their device.

[0968] Operation: When the user clicks the input button, the form data on the device is retrieved.

[0969] Output: The retrieved data is ready to be converted to JSON format.

[0970] Step 2:

[0971] The terminal converts the task details into JSON format.

[0972] Input: Task details entered by the user.

[0973] Operation: The terminal generates JSON data like the following.

[0974] json

[0975] {

[0976] "Task name": "Design for Project A",

[0977] "Deadline": "2023-11-30",

[0978] "Description": "Creating design documents"

[0979] }

[0980] Output: Task details data converted to JSON format.

[0981] Step 3:

[0982] The device sends data in JSON format to the server.

[0983] Input: Task details data converted to JSON format.

[0984] Operation: The terminal sends data to the server as an HTTP POST request.

[0985] Output: JSON data sent to the server.

[0986] Step 4:

[0987] The server receives task details data and saves it to the database.

[0988] Input: JSON data sent from the device.

[0989] Operation: The server parses the received data and saves it to the database as a new task. The server generates a task ID and adds it to the database.

[0990] Output: New task information saved in the database.

[0991] Step 5:

[0992] The server notifies that the task has been created.

[0993] Input: New task information stored in the database.

[0994] Action: The server generates a response indicating that the task was successfully created and sends it back to the terminal.

[0995] Output: A task creation completion notification is displayed on the device.

[0996] Step 6:

[0997] The user enters the progress status of existing tasks.

[0998] Input: The user enters "Project A design task progress: 50%" into the progress update form on the device.

[0999] Operation: When the user clicks the progress update button, the form data is retrieved.

[1000] Output: The retrieved progress information is ready to be converted to JSON format.

[1001] Step 7:

[1002] The device converts the progress information into JSON format.

[1003] Input: Progress information entered by the user.

[1004] Operation: The terminal generates JSON data like the following.

[1005] json

[1006] {

[1007] "Task ID": "123",

[1008] "Progress Status": "50%"

[1009] }

[1010] Output: Progress information converted to JSON format.

[1011] Step 8:

[1012] The device sends progress information data in JSON format to the server.

[1013] Input: Progress information converted to JSON format.

[1014] Operation: The terminal sends data to the server as an HTTP PUT request.

[1015] Output: JSON data sent to the server.

[1016] Step 9:

[1017] The server receives progress information and updates the database.

[1018] Input: JSON data sent from the device.

[1019] Operation: The server parses the received progress information and updates the progress status of the corresponding task in the database.

[1020] Output: Progress information of tasks updated in the database.

[1021] Step 10:

[1022] The server notifies you that the progress update is complete.

[1023] Input: Progress information of tasks updated in the database.

[1024] Operation: The server generates a response indicating that the progress has been successfully updated and sends it back to the terminal.

[1025] Output: A progress update completion notification is displayed on the device.

[1026] Step 11:

[1027] The user requests an update on the progress of all tasks.

[1028] Input: User request.

[1029] Action: The user clicks the progress check button on the device.

[1030] Output: A progress request is sent to the server.

[1031] Step 12:

[1032] The server retrieves the progress of all tasks and returns it in JSON format.

[1033] Input: Progress request from the user.

[1034] Operation: The server retrieves all task information from the database and generates JSON data like the following.

[1035] json

[1036] [

[1037] {

[1038] "Task name": "Design for Project A",

[1039] "Progress Status": "50%"

[1040] "Deadline": "2023-11-30"

[1041] },

[1042] {

[1043] "Task name": "Development of Project B",

[1044] "Progress Status": "80%"

[1045] "Deadline": "2023-12-15"

[1046] }

[1047] ]

[1048] Output: JSON data containing the progress of all tasks.

[1049] Step 13:

[1050] The device receives and visualizes progress data in JSON format.

[1051] Input: JSON data received from the server.

[1052] Operation: The device analyzes the received data and displays it in a Gantt chart or calendar format.

[1053] Output: Visualized task progress displayed on the terminal.

[1054] Step 14:

[1055] The server periodically retrieves progress information for all tasks and assesses the risks.

[1056] Input: Progress information for all tasks stored in the database.

[1057] Operation: The server periodically scans the database to compare the progress and deadlines of each task.

[1058] Output: Results of risk task identification.

[1059] Step 15:

[1060] The server notifies the responsible person of the risky task.

[1061] Input: Task information with identified risks.

[1062] Operation: The server notifies the responsible person of the risk of delay via email or push notification.

[1063] Output: Notification sent to the person in charge.

[1064] Step 16:

[1065] The server collects user emotion data and analyzes it using an emotion engine.

[1066] Input: User input data and operation history.

[1067] Operation: The server passes the collected data to the sentiment engine, which then analyzes it using a machine learning model.

[1068] Output: Analysis results of the user's emotional state.

[1069] Step 17:

[1070] The server generates notifications based on emotional state.

[1071] Input: User's emotional state analysis results.

[1072] Operation: Based on the analysis results, the server generates appropriate notifications for the user. For example, if the user is experiencing high stress levels, it will suggest ways to relax.

[1073] Output: Notifications based on emotional state.

[1074] Step 18:

[1075] The server analyzes emotional data and provides the administrator with an overview of the team's overall emotional trends.

[1076] Input: Sentiment data from multiple users.

[1077] Operation: The server analyzes emotional data and generates data that visually displays the team's stress levels, satisfaction levels, and other metrics.

[1078] Output: Team-wide sentiment trend report for administrators.

[1079] Through the above processing steps, the task management system takes into account the user's emotional state, enabling efficient and highly satisfying task management.

[1080] (Application Example 2)

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

[1082] In factory task management, it is necessary not only to efficiently manage task progress but also to incorporate the recognition of workers' emotions to reduce stress and fatigue. Many conventional task management systems focus on progress and deadlines, failing to consider the emotional state of workers. This can lead to accumulated stress and fatigue, potentially resulting in decreased work efficiency and increased errors. Furthermore, the lack of a method to understand the emotional dynamics of the entire team makes it difficult for managers to take appropriate measures. To address these challenges, a comprehensive task management system that incorporates emotion recognition is necessary.

[1083] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying delays in task progress, means for performing emotion recognition based on operator status information, and means for providing notifications and suggestions based on the results of emotion recognition. This makes it possible to integrate task progress management and operator emotion management. In addition to checking progress and detecting delays early, it is possible to recognize the operator's stress level and take appropriate measures, which is expected to improve work efficiency and reduce errors. Furthermore, by displaying the emotional trends of the entire team, managers can take countermeasures at the appropriate time. This can improve overall work efficiency and operator satisfaction.

[1084] "Task creation" refers to the process where a user inputs new work content and its details into the system, and the system generates a new work item based on that input.

[1085] "Task updating" refers to the process where a user inputs the content and progress of already created work items, and the system then modifies or adds information to the corresponding work items based on that input.

[1086] "Visualization of progress" means that the system displays the progress status of current work items in a format that allows for visual confirmation (e.g., Gantt chart or calendar format).

[1087] "Detection of progress delays" means that the system automatically determines whether a work item is behind schedule.

[1088] "Notification" refers to the system informing users of progress delays or important information via methods such as email or push notifications.

[1089] "Operator status information" refers to information that the worker inputs into the system, such as their work environment, work content, actions, and voice.

[1090] "Emotion recognition" refers to a system analyzing and determining an operator's emotional state based on their voice, actions, and other factors.

[1091] "Notifications and suggestions" refer to the system providing necessary warnings and action suggestions to the operator based on the results of emotion recognition.

[1092] A "generative AI model" refers to artificial intelligence that uses algorithms and networks trained through machine learning to analyze and generate emotional states and other information based on input data.

[1093] An "operator" is a user who uses a system to perform tasks.

[1094] "Team-wide emotional trends" refers to the trend in the overall emotional state of the team, obtained by analyzing emotional data collected from multiple operators.

[1095] The present invention is a task management system that integrates emotion recognition and performs comprehensive task management that takes into account the emotional state of the operator. This system includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of the risk of progress delays, means for performing emotion recognition based on the operator's status information, and means for making notifications and suggestions based on the results of emotion recognition.

[1096] Hardware and software to be used

[1097] The system configuration includes the following hardware and software:

[1098] Hardware: Industrial robots (e.g., robotic arms), smart displays, audio input devices, microphones.

[1099] Software: Python programs, EmotionEngine module, emotion recognition module, task management server API.

[1100] Overview of program processing

[1101] Task creation and update

[1102] The user inputs new work details into the robot within the factory, converts the information into JSON format, and sends it to the task management server. The server stores the task information in a database and generates new tasks. The progress of the created tasks is updated when the user inputs the information through the robot and sends it to the server.

[1103] Task visualization

[1104] Users can check the progress of tasks in real time via devices such as smart displays. All task information is received from the server in JSON format and visually displayed in Gantt charts and calendar formats.

[1105] Risk notification

[1106] The server periodically retrieves task progress information from the database and determines the risk of delays. The determined risk is communicated to the user through various means, including email and push notifications.

[1107] emotion recognition

[1108] An emotion recognition module is used to recognize the emotional state of the operator from their voice and actions while they perform their tasks. The EmotionEngine module analyzes the voice data collected by the robot and evaluates stress levels and satisfaction levels.

[1109] Emotion-based notifications and suggestions

[1110] Based on the assessed emotional state, the system provides the operator with appropriate notifications and suggestions. If the emotional recognition results indicate a high stress level, for example, a suggestion such as "Please take a break" will be sent via the robot.

[1111] Displaying sentiment data

[1112] Emotional data is analyzed on the server, and a function is provided to display the emotional trends of the entire team. This allows administrators to understand the team's emotional state and take appropriate measures.

[1113] Specific example

[1114] 1. Specific examples of creating and updating tasks:

[1115] An operator voice-inputs the task "factory machine maintenance" into the robot and sets the deadline as November 30, 2023. This information is converted to JSON format and sent to the server to generate a new task. When the task progress reaches 50%, the operator inputs the progress into the robot, and the updated information is sent to the server.

[1116] 2. Specific examples of emotion recognition and notification:

[1117] If an operator says "I'm tired" during work, the robot collects the audio, and an emotion recognition module evaluates the stress level. If the evaluation is high, the robot notifies the operator to "take a break."

[1118] 3. Specific examples of emotional data analysis:

[1119] The server analyzes emotional data collected from multiple operators and displays a result to the administrator indicating that "the team's stress level is high." The administrator then takes action based on this result.

[1120] Examples of prompts to input into a generative AI model:

[1121] "Please create a notification message for when a task is behind schedule."

[1122] "Generate suggestions for operators based on emotion recognition."

[1123] "Please generate a report showing the overall sentiment trends of the team."

[1124] This system integrates task progress management with worker emotional management, thereby improving work efficiency and overall satisfaction within the factory.

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

[1126] Step 1: Create a task

[1127] The user provides voice input to the robot specifying the details of a new task and its deadline. The robot converts this information into text and formats it into JSON format. For example, the input data might be "Task Name: 'Factory Machine Maintenance', Deadline: '2023-11-30'". The JSON data is sent to the server, which stores this data in its database and generates a new task.

[1128] Step 2: Update the task

[1129] The user inputs the work progress into the robot via voice. The robot converts this progress information into text and then formats it back into JSON format. The input data is, for example, "Task ID: '123', Progress: '50%'". The data converted to JSON format is sent to the server, which updates the database with information about the corresponding task.

[1130] Step 3: Visualize the task

[1131] The user sends a request from their device to the server to check the progress of their tasks. The server retrieves information on all tasks from the database and sends it back to the device in JSON format. The device parses the received data and displays it in a Gantt chart or calendar format.

[1132] Step 4: Detecting progress delays

[1133] The server periodically retrieves task progress information from the database and determines if there are any delays compared to the deadline. For comparison, data such as "Task ID: '123', Current Progress: '50%', Deadline: '2023-11-30'" is used. Tasks that are behind schedule are identified, and the server notifies the user of the delay risk.

[1134] Step 5: Emotion Recognition

[1135] An operator provides voice input to the robot while performing a task. The robot collects this voice data and sends it to an emotion recognition module. The emotion recognition module analyzes the voice data and determines the emotional state. An example of the input data is "audio data: 'audio_sample.wav'". The determined emotional state is output as a numerical value, such as a stress level.

[1136] Step 6: Emotion-based notifications and suggestions

[1137] Based on the emotional state data received from the emotion recognition module, the server generates necessary notifications and suggestions for the operator. If the emotional data indicates a "high stress level," the server notifies the operator to "take a break." Specific notification content, such as "recommendation to take a break," is generated, and the robot communicates this information to the operator via voice.

[1138] Step 7: Displaying emotion data

[1139] The server analyzes emotional data collected from multiple operators to visualize the emotional trends of the entire team. The analyzed data is sent to terminals and displayed on smart displays, etc. For example, the displayed content might be "Team-wide stress level: 'High'". This allows administrators to understand the emotional state of the entire team.

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

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

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

[1143] [Third Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1156] This invention is a system that manages tasks created and updated by users, visualizes the progress of tasks, detects delay risks, and provides timely notifications. The implementation of this system is described below.

[1157] Task creation and update

[1158] When a user creates a task, they first enter the task details (task name, due date, assignee, dependent tasks, etc.) from their device. The device then sends this information to the task management server in JSON format. The server saves the received data to its database, and a new task is created. For example, a user can create a task called "Design Project X" and set its due date to October 10, 2023.

[1159] When a user updates the progress of a task, they enter the current progress percentage (e.g., 50%) from their terminal and send it to the server. The server updates the progress data in the database and reflects the information in other tasks related to that task. For example, a user can set the progress of "Design Project X" to 50%.

[1160] Task visualization

[1161] To check the progress of tasks, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device visualizes the retrieved task information in a format such as a Gantt chart or calendar. This makes it easier for the user to see the progress of all tasks at a glance. For example, the progress of "Project X Design" is displayed as 50% on the Gantt chart.

[1162] Risk notification

[1163] To detect the risk of tasks falling behind schedule, the server periodically monitors the progress of all tasks. The server compares the progress of tasks with their deadlines to identify tasks that are at risk of not meeting their deadlines. This risk assessment is based on the remaining time and the required progress. For example, if task "Development of Project Y" is 20% complete and its deadline is November 1, 2023, the server will determine that this task is behind schedule.

[1164] If a delay risk is detected, the server sends a notification to the person in charge of the relevant task via email or push notification. This allows the person in charge to take immediate action. For example, the server sends a notification to the person in charge of "Development of Project Y" stating, "Task 'Development of Project Y' is likely to be delayed."

[1165] These features allow users to eliminate wasted time on progress checks, manage tasks efficiently, and detect and address risks early. The system of this invention automates, visualizes, and provides timely notifications for task management, thereby improving operational efficiency and avoiding risks.

[1166] The following describes the processing flow.

[1167] Task creation and update

[1168] Task creation

[1169] Step 1:

[1170] The user enters task details (task name, due date, assignee, dependent tasks, etc.) on their device. This information is entered as a form.

[1171] Step 2:

[1172] The terminal converts the entered task information into JSON format and sends a POST request to the task management server.

[1173] Step 3:

[1174] The server parses the received request and extracts task information.

[1175] Step 4:

[1176] The server saves task information to the database. A task ID is also issued for newly created tasks.

[1177] Step 5:

[1178] The server verifies that the task was created successfully and returns a success message to the terminal.

[1179] Task update

[1180] Step 1:

[1181] To update the progress, the user enters the task's progress percentage (e.g., 50%) on their device.

[1182] Step 2:

[1183] The terminal converts the update information into JSON format and sends a PUT request to the task management server.

[1184] Step 3:

[1185] The server parses the received request and extracts the target task ID and the updated progress information.

[1186] Step 4:

[1187] The server updates the progress information of the relevant task in the database.

[1188] Step 5:

[1189] The server confirms that the task progress has been successfully updated and returns a success message to the terminal.

[1190] Task visualization

[1191] Step 1:

[1192] To check the progress of all tasks, the user requests task information on their device. This is sent as a GET request to the server.

[1193] Step 2:

[1194] The server retrieves progress information for all tasks from the database.

[1195] Step 3:

[1196] The server converts the acquired task information into JSON format and sends it back to the terminal.

[1197] Step 4:

[1198] The terminal analyzes the received task information and displays it to the user in a Gantt chart or calendar format.

[1199] Risk notification

[1200] Step 1:

[1201] The server periodically retrieves progress information for all tasks from the database and compares it with the task deadlines.

[1202] Step 2:

[1203] The server compares progress with deadlines and identifies tasks that may not be completed by the deadline.

[1204] Step 3:

[1205] The server retrieves the information of the person responsible for the identified risk task and generates a notification indicating a risk of delay.

[1206] Step 4:

[1207] The server sends the generated notification content to the responsible person's terminal via email or push notification.

[1208] Step 5:

[1209] The device displays received notifications to the user and informs them about the risk of delays.

[1210] (Example 1)

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

[1212] Traditional task management systems had problems with efficiently creating and updating tasks, visualizing progress, and notifying users of delay risks. In particular, when multiple tasks were dependent on each other or in large-scale projects, it was difficult to grasp progress in real time and detect delay risks early, which raised concerns about a decrease in overall work efficiency.

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

[1214] In this invention, the server includes means for the user to input detailed task information, means for transmitting the input information to the server, means for the server to store the received information in a database, means for the user to update the task progress, means for transmitting the progress data to the server, means for the server to update the database with the received progress data, means for the user to send a request to retrieve task information, means for the server to retrieve all task information from the database and send it back to the terminal, means for the terminal to visualize the received task information, means for the server to periodically monitor the task progress and evaluate the risk of delay, and means for notifying the evaluation results. This enables real-time task management and visualization of progress, as well as rapid detection and notification of delay risks.

[1215] A "user" refers to an individual or legal entity that uses the system to create tasks, update their progress, or check their progress.

[1216] A "terminal" refers to an electronic device used by a user to input information or display data from a server.

[1217] A "server" refers to a computing system used for managing task information, storing data, monitoring progress, and providing notifications.

[1218] A "database" refers to an information management system used by a server to store task information and progress data.

[1219] A "task" refers to a series of actions or activities that a user creates to achieve a specific objective.

[1220] "Progress status" refers to information indicating the extent to which a task has been completed.

[1221] "Visualization" refers to the process of displaying the progress of a task in an easy-to-understand way for the user.

[1222] "Risk" refers to a situation where the progress of a task may fall behind schedule.

[1223] "Notification" refers to a means of communication used by a server to inform the person in charge of a task about the risk of delays.

[1224] "JSON format" is an abbreviation for JavaScript Object Notation, and refers to a lightweight data exchange format for structurally representing data.

[1225] This invention provides a system for efficiently managing user-created and updated tasks, visualizing progress, and detecting and notifying users of delay risks at an early stage. The configuration for implementing this system is described below.

[1226] Task creation and update

[1227] The user first enters task details (task name, due date, assignee, dependent tasks, etc.) into the terminal. This information is converted to JSON format and sent to the task management server. The server saves the received data to its database, and a new task is created. For example, a user might create a task called "Design Project X" and set the due date to October 10, 2023. When the user updates the task's progress, they enter the progress percentage (e.g., 50%) from the terminal and send it to the server. The server saves the received progress data to its database and reflects the information in other tasks related to that task. For example, a user might set the progress of "Design Project X" to 50%.

[1228] Task visualization

[1229] To check the progress of a task, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device visualizes the retrieved task information in a format such as a Gantt chart or calendar, allowing the user to see the progress of all tasks at a glance. For example, the progress of "Project X Design" may be displayed as 50% on the Gantt chart.

[1230] Risk notification

[1231] The server periodically monitors the progress of all tasks, comparing progress with deadlines to assess the risk of delay. This assessment is based on the remaining time and required progress, and if there is a risk of delay, the server sends a notification to the person in charge of the task via email or push notification. For example, if task "Development of Project Y" is 20% complete and due on November 1, 2023, the server will determine that this task is behind schedule and send a notification to the person in charge stating, "Task 'Development of Project Y' is likely to be delayed."

[1232] These features allow users to eliminate wasted time on progress checks, manage tasks efficiently, and detect and address risks early. The system of this invention automates, visualizes, and provides timely notifications for task management, thereby improving operational efficiency and avoiding risks.

[1233] Command example

[1234] By using a generative AI model, you can receive explanations and help for each function by entering prompts like the following.

[1235] Examples of prompts for a generative AI model:

[1236] Please explain each function of the following task management system in clear, natural language.

[1237] Task creation and update

[1238] When a user creates a task, they enter the task details (task name, due date, assignee, dependent tasks, etc.) from their device. The device sends this information to the task management server in JSON format. The server saves the received data to its database, and a new task is created.

[1239] Example: A user creates a task called "Design Project X" and sets the deadline to October 10, 2023.

[1240] When a user updates the progress of a task, they enter the current progress percentage (e.g., 50%) from their device and send it to the server. The server updates the progress data in the database and reflects the information in other tasks related to that task.

[1241] Specific example: The user sets the progress of "Project X Design" to 50%.

[1242] Task visualization

[1243] To check the progress of their tasks, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device then visualizes the retrieved task information in a format such as a Gantt chart or calendar.

[1244] Specific example: The progress of "Project X Design" is displayed as 50% on the Gantt chart.

[1245] Risk notification

[1246] The server periodically monitors the progress of all tasks to detect the risk of tasks falling behind schedule. The server compares task progress with deadlines to identify tasks at risk of missing deadlines. This risk assessment is based on the remaining time and the required progress.

[1247] Specific example: If task "Development of Project Y" is 20% complete and due on November 1, 2023, the server will determine that this task is behind schedule.

[1248] If a delay risk is detected, the server will send a notification to the person responsible for the relevant task via email or push notification.

[1249] Specific example: The server sends a notification to the person in charge of "Development of Project Y" stating, "Task 'Development of Project Y' is likely to be delayed."

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

[1251] Step 1:

[1252] The user enters the task details.

[1253] The user uses their device to enter details about the new task (task name, due date, assignee, dependent tasks, etc.).

[1254] Input: User-entered task name "Project X Design", deadline "October 10, 2023", assignee "Taro Yamada", dependent task "Project W Review", etc.

[1255] Data processing: The terminal converts the entered information into JSON format.

[1256] Output: Task information in JSON format: "{'taskName': 'Project X Design', 'deadline': '2023-10-10', 'assignee': 'Taro Yamada', 'dependency': 'Project W Review'}".

[1257] Step 2:

[1258] The device sends task data to the server.

[1259] The terminal sends the converted JSON-formatted task information to the task management server.

[1260] Input: Task information in JSON format.

[1261] Data processing: None (simple data transfer).

[1262] Output: Task information sent to the server.

[1263] Step 3:

[1264] The server saves the task information it receives to the database.

[1265] The server saves the received task information to the database and registers it as a new task.

[1266] Input: Received task information in JSON format.

[1267] Data processing: Convert the data to a format suitable for the database and save it as a new record in the database.

[1268] Output: A new task record added to the database.

[1269] Step 4:

[1270] The user enters the task progress.

[1271] The user uses their device to input the progress of an existing task (e.g., 50%).

[1272] Input: User-entered task name "Project X Design", progress "50%".

[1273] Data processing: The terminal converts the entered information into JSON format.

[1274] Output: Progress information in JSON format: "{'taskName': 'Project X Design', 'progress': 50}".

[1275] Step 5:

[1276] The device sends progress data to the server.

[1277] The terminal sends the converted JSON-formatted progress information to the task management server.

[1278] Input: Progress information in JSON format.

[1279] Data processing: None (simple data transfer).

[1280] Output: Progress information sent to the server.

[1281] Step 6:

[1282] The server updates the database with progress information.

[1283] The server saves the received progress information to the database and updates the progress status of the relevant task. It also reflects the information in other tasks related to that task.

[1284] Input: Received progress information in JSON format.

[1285] Data processing: Update the progress of the relevant task in the database. Also update related tasks.

[1286] Output: Updated task records in the database.

[1287] Step 7:

[1288] A user submits a request to retrieve task information.

[1289] The user uses their terminal to send a request to the server to retrieve information about all tasks.

[1290] Input: Task information retrieval request.

[1291] Data processing: None (simple request).

[1292] Output: The request sent to the server.

[1293] Step 8:

[1294] The server retrieves task information from the database.

[1295] The server retrieves information on all tasks from the database and converts it to JSON format.

[1296] Input: Task information retrieval request.

[1297] Data processing: Execute database queries to retrieve task information and convert it to JSON format.

[1298] Output: Task information in JSON format.

[1299] Step 9:

[1300] The server sends task information back to the terminal.

[1301] The server returns the converted task information in JSON format to the terminal.

[1302] Input: Task information in JSON format.

[1303] Data processing: None (simple data transfer).

[1304] Output: Task information sent to the terminal.

[1305] Step 10:

[1306] The device visualizes task information.

[1307] The device uses the received task information to visualize it in a Gantt chart or calendar format.

[1308] Input: Received task information in JSON format.

[1309] Data processing: Convert task information into Gantt charts and calendar formats.

[1310] Output: Displayed task information (e.g., "Project X Design" progress: 50%).

[1311] Step 11:

[1312] The server monitors the progress of the task.

[1313] The server periodically retrieves the progress of all tasks from the database, compares the progress with the deadline, and assesses the risk of delays.

[1314] Input: All task information in the database.

[1315] Data processing: Compare progress with deadlines and assess the risk of delays.

[1316] Output: Delay risk assessment results.

[1317] Step 12:

[1318] The server will notify you of the risk of delay.

[1319] The server sends notifications via email or push notification to the person responsible for the task where a delay risk has been identified.

[1320] Input: Delay risk assessment results.

[1321] Data processing: Generate and send a notification message.

[1322] Output: Notification sent to the person in charge (e.g., "Task 'Development of Project Y' is likely to be delayed.").

[1323] (Application Example 1)

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

[1325] Traditional task management systems required users to use desktop or mobile devices to create tasks, update progress, and receive notifications about delay risks, resulting in cumbersome manual data entry. Furthermore, they often lacked real-time visualization of progress and risk notifications, making quick responses difficult.

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

[1327] In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of delays in task progress, means for inputting tasks and updating their progress using smart glasses, means for visualizing the progress displayed on the smart glasses, and means for notifying the smart glasses of delay risks. This enables users to manage tasks hands-free, check progress and risks in real time, and take quick countermeasures.

[1328] "Means for creating and updating tasks" refers to a function that allows users to input new tasks and send detailed information about those tasks to the server for storage in the database.

[1329] "Means of visualizing task progress" refers to a function where the server retrieves task information from a database and displays it in a format that is easy for the user to understand visually.

[1330] "A means of detecting and notifying about delays in task progress" refers to a function in which the server compares the progress and deadline of a task, identifies tasks at risk of delay, and notifies the user of that information.

[1331] "A means of inputting tasks and updating progress using smart glasses" refers to a function that allows users to input detailed task information and progress using voice commands or gestures through smart glasses, and to send that information to a server.

[1332] "Means of visualizing progress displayed on smart glasses" refers to a function that displays the progress of tasks on the smart glasses' screen in the form of a Gantt chart or calendar.

[1333] "A means of providing delay risk notifications to smart glasses" refers to a function that displays delay risk notifications sent from the server on smart glasses, enabling users to respond quickly.

[1334] Modes for carrying out the invention

[1335] This invention is a system that manages tasks created and updated by users, visualizes the progress of tasks, detects delay risks, and provides timely notifications. Specific embodiments thereof are described below.

[1336] Task creation and update

[1337] When a user creates a task, they input task details (task name, due date, assignee, dependent tasks, etc.) into the smart glasses using voice commands or gestures. The smart glasses send this information to the task management server in JSON format, and the server stores the received data in its database and creates a new task. For example, a user can create a task called "Design a New Project" and set the due date to a specific date.

[1338] To update task progress, the user similarly inputs the current progress level into their smart glasses using voice commands or gestures and sends it to the server. The server updates the progress data in its database and reflects the information in other tasks related to that task. For example, a user can set the progress of "Design a New Project" to 50%.

[1339] Task visualization

[1340] To check the progress of tasks, the user sends a request to the server via smart glasses to retrieve all tasks. The server retrieves task information from the database and returns it to the smart glasses in JSON format. The progress of tasks is displayed on the smart glasses' screen in the form of a Gantt chart or calendar. This makes it easy for the user to see the progress of all tasks at a glance. For example, the progress of "Designing a New Project" is displayed on the Gantt chart.

[1341] Risk notification

[1342] To detect the risk of tasks falling behind schedule, the server periodically monitors the progress of all tasks. The server compares the progress of tasks with their deadlines to identify tasks that are at risk of not being met. This risk assessment is based on the remaining time and the required progress. For example, if a task is 20% complete and has a deadline of a specific date, the server will determine that this task is behind schedule.

[1343] If a delay risk is detected, the server sends a push notification to the smart glasses, displaying the notification to the person responsible for the relevant task. This allows the person responsible to take immediate action. For example, the server might send a notification to the person responsible for "Designing a New Project" stating, "This task is likely to be delayed."

[1344] Specific example

[1345] For example, consider a task management scenario in a factory. The user (worker) wears smart glasses and inputs the next task using voice or gestures. The worker can create a new task, such as "check the assembly line," and update its progress in real time. The server monitors the task's progress and sends a notification to the smart glasses if the progress is behind schedule despite the approaching deadline, alerting the user to the risk.

[1346] Example of a prompt

[1347] Please enter the task details. Include the task name, due date, assignee, and dependent tasks.

[1348] This system allows users to manage tasks effortlessly and perform their work efficiently. It also enables early detection of risks and prompt action.

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

[1350] Step 1:

[1351] The user inputs task details into smart glasses using voice commands or gestures. This includes information such as the task name, due date, assignee, and dependent tasks. The smart glasses convert this information into JSON format and send it to the task management server.

[1352] Input: Enter task details (task name, due date, assignee, dependent tasks) using voice or gestures.

[1353] Processing: Smart glasses analyze voice or gestures and convert them into JSON format.

[1354] Output: Task information converted to JSON format is sent to the server.

[1355] Step 2:

[1356] The server saves the received task information to the database and creates a new task. The server parses the JSON data and writes it to the database in the appropriate format.

[1357] Input: Task information in JSON format.

[1358] Processing: The server parses the JSON and saves it to the database.

[1359] Output: A new task is added to the database.

[1360] Step 3:

[1361] The user updates task progress via smart glasses. Progress is entered via voice or gestures, and the smart glasses convert this into JSON format and send it to the server.

[1362] Input: Enter the progress percentage (e.g., 50%) using voice or gestures.

[1363] Processing: The smart glasses analyze the input and convert it to JSON format.

[1364] Output: Sends progress information in JSON format to the server.

[1365] Step 4:

[1366] The server updates the database with the received progress information, and the progress is reflected in the relevant task and related tasks. The server analyzes the progress information and updates the progress of the relevant task.

[1367] Input: Progress information in JSON format.

[1368] Processing: The server parses the JSON and updates the progress of the corresponding task in the database.

[1369] Output: Task information in the database is updated.

[1370] Step 5:

[1371] The user uses smart glasses to check the progress of all tasks. A request to retrieve all tasks is sent from the smart glasses to the server.

[1372] Input: A request to check the progress of all tasks.

[1373] Processing: The server retrieves task information from the database and sends it back to the smart glasses in JSON format.

[1374] Output: Task information in JSON format is sent to the smart glasses.

[1375] Step 6:

[1376] The smart glasses display received task information in Gantt chart and calendar formats. This allows users to check the progress of all tasks hands-free.

[1377] Input: Task information in JSON format.

[1378] Processing: Smart glasses parse the JSON data and convert it into a Gantt chart or calendar for display.

[1379] Output: Visualized task progress is displayed on the smart glasses' screen.

[1380] Step 7:

[1381] The server periodically monitors the progress of tasks and detects tasks at risk of delay. The server compares the progress with the deadline to make a determination.

[1382] Input: Task progress information and deadline information from the database.

[1383] Processing: The server compares progress and deadlines to identify tasks at risk of delay.

[1384] Output: Delay risk assessment result.

[1385] Step 8:

[1386] When a delay risk is detected, the server sends a push notification to the smart glasses, displaying the notification to the person responsible for the relevant task. This allows the user to take immediate action.

[1387] Input: Delay risk assessment result.

[1388] Processing: The server generates a push notification and sends it to the smart glasses.

[1389] Output: A delay risk notification is displayed on the smart glasses.

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

[1391] This invention provides a more efficient and satisfying work environment by combining a task management system with an emotion engine, enabling notifications and task management based on the user's emotions. This system includes means for creating and updating tasks, means for visualizing progress, means for detecting and notifying of delays in progress, and an emotion engine that recognizes the user's emotions.

[1392] Task creation and update

[1393] Task creation:

[1394] The user enters task details on their device. The device converts this information into JSON format and sends it to the task management server. The server stores the task information in its database and generates a new task.

[1395] Task update:

[1396] The user enters the progress status on the terminal, and the terminal converts this information into JSON format and sends it to the server. The server updates the progress information for the corresponding task in the database.

[1397] Task visualization

[1398] The user sends a request from their device to the server to check the progress of all tasks. The server retrieves information on all tasks from the database and sends it back to the device in JSON format. The device then parses the task information and displays it in a Gantt chart or calendar format.

[1399] Risk notification

[1400] The server periodically retrieves progress information for all tasks from the database and compares it with task deadlines. By comparing progress and deadlines, it identifies tasks that are likely to not be completed on time. Assignees of identified risk tasks are notified of the delay risk via email or push notification.

[1401] Emotional Engine

[1402] Emotion recognition:

[1403] The server analyzes user input data, operation history, and other relevant data to recognize the user's emotions. The emotion engine uses machine learning models to determine the user's emotional state (e.g., stress, satisfaction, anxiety). Information as the user enters or updates tasks is also sent to the emotion engine and used for analysis.

[1404] Emotion-based notifications:

[1405] The emotion engine analyzes the user's emotional state and generates notifications tailored to that specific emotional state. For example, if the user is feeling stressed, the server will notify them with a suggestion to "relax." Similarly, if there is a high risk of delays, the server will provide a notification that takes the user's emotional state into consideration.

[1406] Displaying sentiment data:

[1407] The server also analyzes emotional data collected from multiple users and provides a function to display the emotional trends of the entire team. This allows administrators to understand the emotional state of the entire team and take necessary actions. For example, if many team members are experiencing stress, the server will provide this information to the administrator and suggest countermeasures.

[1408] Specific example

[1409] Example 1:

[1410] A user creates a task called "Design Project A" and sets the deadline to November 30, 2023. If progress starts to fall behind, the server detects this and notifies the user. At the same time, if the emotion engine determines that the user's stress level is high, it also makes suggestions for stress reduction.

[1411] Example 2:

[1412] In projects involving multiple team members, if overall progress is behind schedule, the server uses an emotion engine to analyze the emotional state of all team members. It then provides the results to the administrator and suggests appropriate actions.

[1413] These features allow the task management system to not only manage task progress but also contribute to managing user emotions, thereby improving overall work efficiency and user satisfaction. The system of this invention realizes a more human-centered task management environment by taking user emotions into consideration.

[1414] The following describes the processing flow.

[1415] Task creation and update

[1416] Task creation

[1417] Step 1:

[1418] The user enters details of a new task on their device. Specifically, they use a form to enter items such as the task name, due date, assignee, and dependent tasks.

[1419] Step 2:

[1420] The terminal converts the entered task information into JSON format and sends a POST request to the task management server.

[1421] Step 3:

[1422] The server parses the received request and extracts task information.

[1423] Step 4:

[1424] The server saves task information to the database. At the same time, it generates an ID for the newly created task.

[1425] Step 5:

[1426] The server confirms that the task was created successfully and sends a success message and a new task ID back to the terminal.

[1427] Task update

[1428] Step 1:

[1429] Users update the task progress by entering the progress percentage (e.g., 50%) on their device. Use an update form or interactive element.

[1430] Step 2:

[1431] The terminal converts the progress information into JSON format and sends a PUT request to the task management server.

[1432] Step 3:

[1433] The server analyzes the received request and extracts the target task ID and progress information.

[1434] Step 4:

[1435] The server updates the progress information of the relevant task in the database.

[1436] Step 5:

[1437] The server confirms that the task progress has been successfully updated and sends a success message back to the terminal.

[1438] Task visualization

[1439] Step 1:

[1440] To check the progress of all tasks, the user requests task information on their device. This is sent as a GET request to the server.

[1441] Step 2:

[1442] The server retrieves progress information for all tasks from the database.

[1443] Step 3:

[1444] The server converts the acquired task information into JSON format and sends it back to the terminal.

[1445] Step 4:

[1446] The terminal analyzes the received task information and displays it to the user in a Gantt chart or calendar format.

[1447] Risk notification

[1448] Step 1:

[1449] The server periodically retrieves progress information for all tasks from the database and compares it with the task deadlines.

[1450] Step 2:

[1451] The server compares progress with deadlines and identifies tasks that may not be completed by the deadline.

[1452] Step 3:

[1453] The server retrieves the information of the person responsible for the identified risk task and generates a notification indicating a risk of delay.

[1454] Step 4:

[1455] The server sends the generated notification content to the responsible person's terminal via email or push notification.

[1456] Step 5:

[1457] The device displays received notifications to the user and informs them about the risk of delays.

[1458] Emotional Engine

[1459] Step 1:

[1460] The server periodically collects user input data and operation history, and analyzes it using an emotion engine.

[1461] Step 2:

[1462] The emotion engine uses machine learning models to determine the user's emotional state based on collected data. For example, it can identify stress levels, satisfaction levels, and so on.

[1463] Step 3:

[1464] When a user enters or updates a task, data from the device is sent to the sentiment engine and used for sentiment analysis.

[1465] Step 4:

[1466] The emotion engine generates appropriate notifications for the user based on the determined emotional state. For example, if the user is experiencing high stress, it will suggest relaxation techniques.

[1467] Step 5:

[1468] The server sends the generated notification content to the user's device via email or push notification.

[1469] Step 6:

[1470] The server analyzes the emotional data of multiple users and generates data to display the emotional trends of the entire team.

[1471] Step 7:

[1472] Administrators can monitor the emotional state of the entire team through their devices and take necessary measures. For example, if many members are experiencing high levels of stress, they can use that information to provide support.

[1473] (Example 2)

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

[1475] Traditional task management systems can track task progress and notify users of delays, but they lack the ability to consider users' emotional states, making efficient task management difficult. In particular, ignoring emotional factors such as user stress and satisfaction can hinder task progress. Furthermore, the lack of means for managers to understand the emotional dynamics of the entire team makes appropriate responses difficult.

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

[1477] In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of delays in task progress, means for recognizing user emotions and notifying based on the analysis results, and means for analyzing user and multiple user emotion data and presenting it to the administrator. This enables efficient and highly satisfying task management that takes into account the emotional state of users.

[1478] A "task" refers to a unit of work or task that a user performs to achieve a specific objective.

[1479] "Means" refers to the methods or mechanisms that a system uses to achieve a specific function.

[1480] A "server" refers to a computer system that provides or processes data in response to requests from clients.

[1481] A "terminal" refers to a device that a user uses to access and operate a system. Examples include personal computers, smartphones, and tablets.

[1482] "Users" refer to the people who use this system to create, update, and manage tasks.

[1483] "Means for creating and updating tasks" refers to a system that provides users with the functionality to create new tasks and modify information about existing tasks.

[1484] "Means of visualizing task progress" refers to a system that provides a function to visually display the progress of tasks. For example, it can be displayed in a Gantt chart or calendar format.

[1485] "Means for detecting and notifying about delays in task progress" refers to a system that compares the progress of a task with its deadline and provides a function to notify the user if there is a risk of delay.

[1486] "A means of recognizing user emotions and providing notifications based on the analysis results" refers to a system that analyzes user input data and operation history, recognizes the user's emotional state, and provides a function to generate notifications corresponding to specific emotional states.

[1487] "Means of analyzing and presenting emotional data of users or multiple users to administrators" refers to a system that provides functions for collecting and analyzing emotional data of users or entire teams and providing the results to administrators.

[1488] "Notification" refers to a means by which a system communicates information to a user. Specifically, this includes email and push notifications.

[1489] "Visualization" refers to the visual display of data and information. This includes, for example, displaying data using graphs and charts.

[1490] An "emotion engine" refers to a software component that includes a machine learning model for analyzing and recognizing a user's emotional state.

[1491] A "machine learning model" refers to an algorithm that learns from large amounts of data and uses that data to perform inferences and predictions.

[1492] This invention is a task management system that takes user emotions into consideration, and by providing means for creating and updating tasks, means for visualizing progress, means for detecting and notifying of progress delays, and an emotion engine, it provides an efficient and highly satisfying work environment.

[1493] Task creation and update

[1494] Task creation:

[1495] The user enters details such as the task name, due date, and description into a task creation form on their device. This detailed information is converted to JSON format by the device and sent to the server. The server parses the received JSON data and saves it as a new task in the database. For example, if a user creates a task called "Design Project A" and sets the due date to November 30, 2023, the device converts this information to JSON format and sends it to the server via an HTTP POST request.

[1496] Task update:

[1497] The user enters the progress status of an existing task (e.g., 50%) on their device. This information is also converted to JSON format by the device and sent to the server. The server reflects the received progress information in the corresponding task in the database and updates the progress status.

[1498] Task visualization

[1499] When a user sends a request from their device to check the progress of all tasks, the server retrieves information on all tasks from the database and sends it back in JSON format. The device then parses the received JSON data and displays it visually in a Gantt chart or calendar format. This allows the user to grasp the progress of each task at a glance.

[1500] Risk notification

[1501] The server periodically retrieves progress information for all tasks from the database and compares the progress with the deadline. If a task is found to be behind schedule, the server notifies the task's assignee of the delay risk via email or push notification. For example, if a task due on November 30, 2023, is less than 20% complete, it will be flagged as a risk task and the assignee will be notified.

[1502] Emotional Engine

[1503] Emotion recognition:

[1504] The server collects user input data and operation history, and uses an emotion engine to analyze the user's emotional state. The emotion engine uses machine learning models to determine the user's stress, satisfaction, and anxiety levels. For example, if the frequency of task updates is low and there are signs of anxiety in the operation history, the server will determine that the user's stress level is high.

[1505] Emotion-based notifications:

[1506] Based on the emotion engine's analysis of the user's emotional state, the server generates notifications tailored to that specific emotional state. For example, if the user is feeling stressed, it sends a notification suggesting a break to relax.

[1507] Displaying sentiment data:

[1508] The server analyzes the emotional data collected from multiple users and presents the overall emotional trends of the team to the administrator. This allows the administrator to understand the emotional state of the entire team and take necessary actions. For example, if many team members are experiencing stress, this information is provided to the administrator, and countermeasures are suggested.

[1509] Specific example

[1510] Example 1:

[1511] A user creates a task called "Design Project A" and sets the deadline to November 30, 2023. If progress starts to fall behind, the server detects this and notifies the user. At the same time, if the emotion engine determines that the user's stress level is high, it also makes suggestions for stress reduction.

[1512] Example 2:

[1513] In projects involving multiple team members, if overall progress is behind schedule, the server uses an emotion engine to analyze the emotional state of all team members. It then provides the results to the administrator and suggests appropriate actions.

[1514] Example of a prompt

[1515] "Create a design task for Project A and set the deadline to November 30, 2023."

[1516] "Please update the progress of the design task for Project A to 50%."

[1517] "Please show the progress of all tasks."

[1518] "Please check for any progress risks in tasks with approaching deadlines, and notify us if any risks exist."

[1519] "Determine the user's emotional state based on their activity history."

[1520] "Please create a notification for when a user's stress level is high."

[1521] "Analyze the emotional state of the entire team and notify the manager."

[1522] Thus, the system of the present invention, in addition to conventional task management functions, utilizes an emotion engine to manage tasks while taking into account the user's emotional state, thereby improving operational efficiency and user satisfaction.

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

[1524] Step 1:

[1525] The user enters the task details.

[1526] Input: The user enters details such as the task name "Design Project A," deadline, and description into the task creation form on their device.

[1527] Operation: When the user clicks the input button, the form data on the device is retrieved.

[1528] Output: The retrieved data is ready to be converted to JSON format.

[1529] Step 2:

[1530] The terminal converts the task details into JSON format.

[1531] Input: Task details entered by the user.

[1532] Operation: The terminal generates JSON data like the following.

[1533] json

[1534] {

[1535] "Task name": "Design for Project A",

[1536] "Deadline": "2023-11-30",

[1537] "Description": "Creating design documents"

[1538] }

[1539] Output: Task details data converted to JSON format.

[1540] Step 3:

[1541] The device sends data in JSON format to the server.

[1542] Input: Task details data converted to JSON format.

[1543] Operation: The terminal sends data to the server as an HTTP POST request.

[1544] Output: JSON data sent to the server.

[1545] Step 4:

[1546] The server receives task details data and saves it to the database.

[1547] Input: JSON data sent from the device.

[1548] Operation: The server parses the received data and saves it to the database as a new task. The server generates a task ID and adds it to the database.

[1549] Output: New task information saved in the database.

[1550] Step 5:

[1551] The server notifies that the task has been created.

[1552] Input: New task information stored in the database.

[1553] Action: The server generates a response indicating that the task was successfully created and sends it back to the terminal.

[1554] Output: A task creation completion notification is displayed on the device.

[1555] Step 6:

[1556] The user enters the progress status of existing tasks.

[1557] Input: The user enters "Project A design task progress: 50%" into the progress update form on the device.

[1558] Operation: When the user clicks the progress update button, the form data is retrieved.

[1559] Output: The retrieved progress information is ready to be converted to JSON format.

[1560] Step 7:

[1561] The device converts the progress information into JSON format.

[1562] Input: Progress information entered by the user.

[1563] Operation: The terminal generates JSON data like the following.

[1564] json

[1565] {

[1566] "Task ID": "123",

[1567] "Progress Status": "50%"

[1568] }

[1569] Output: Progress information converted to JSON format.

[1570] Step 8:

[1571] The device sends progress information data in JSON format to the server.

[1572] Input: Progress information converted to JSON format.

[1573] Operation: The terminal sends data to the server as an HTTP PUT request.

[1574] Output: JSON data sent to the server.

[1575] Step 9:

[1576] The server receives progress information and updates the database.

[1577] Input: JSON data sent from the device.

[1578] Operation: The server parses the received progress information and updates the progress status of the corresponding task in the database.

[1579] Output: Progress information of tasks updated in the database.

[1580] Step 10:

[1581] The server notifies you that the progress update is complete.

[1582] Input: Progress information of tasks updated in the database.

[1583] Operation: The server generates a response indicating that the progress has been successfully updated and sends it back to the terminal.

[1584] Output: A progress update completion notification is displayed on the device.

[1585] Step 11:

[1586] The user requests an update on the progress of all tasks.

[1587] Input: User request.

[1588] Action: The user clicks the progress check button on the device.

[1589] Output: A progress request is sent to the server.

[1590] Step 12:

[1591] The server retrieves the progress of all tasks and returns it in JSON format.

[1592] Input: Progress request from the user.

[1593] Operation: The server retrieves all task information from the database and generates JSON data like the following.

[1594] json

[1595] [

[1596] {

[1597] "Task name": "Design for Project A",

[1598] "Progress Status": "50%"

[1599] "Deadline": "2023-11-30"

[1600] },

[1601] {

[1602] "Task name": "Development of Project B",

[1603] "Progress Status": "80%"

[1604] "Deadline": "2023-12-15"

[1605] }

[1606] ]

[1607] Output: JSON data containing the progress of all tasks.

[1608] Step 13:

[1609] The device receives and visualizes progress data in JSON format.

[1610] Input: JSON data received from the server.

[1611] Operation: The device analyzes the received data and displays it in a Gantt chart or calendar format.

[1612] Output: Visualized task progress displayed on the terminal.

[1613] Step 14:

[1614] The server periodically retrieves progress information for all tasks and assesses the risks.

[1615] Input: Progress information for all tasks stored in the database.

[1616] Operation: The server periodically scans the database to compare the progress and deadlines of each task.

[1617] Output: Results of risk task identification.

[1618] Step 15:

[1619] The server notifies the responsible person of the risky task.

[1620] Input: Task information with identified risks.

[1621] Operation: The server notifies the responsible person of the risk of delay via email or push notification.

[1622] Output: Notification sent to the person in charge.

[1623] Step 16:

[1624] The server collects user emotion data and analyzes it using an emotion engine.

[1625] Input: User input data and operation history.

[1626] Operation: The server passes the collected data to the sentiment engine, which then analyzes it using a machine learning model.

[1627] Output: Analysis results of the user's emotional state.

[1628] Step 17:

[1629] The server generates notifications based on emotional state.

[1630] Input: User's emotional state analysis results.

[1631] Operation: Based on the analysis results, the server generates appropriate notifications for the user. For example, if the user is experiencing high stress levels, it will suggest ways to relax.

[1632] Output: Notifications based on emotional state.

[1633] Step 18:

[1634] The server analyzes emotional data and provides the administrator with an overview of the team's overall emotional trends.

[1635] Input: Sentiment data from multiple users.

[1636] Operation: The server analyzes emotional data and generates data that visually displays the team's stress levels, satisfaction levels, and other metrics.

[1637] Output: Team-wide sentiment trend report for administrators.

[1638] Through the above processing steps, the task management system takes into account the user's emotional state, enabling efficient and highly satisfying task management.

[1639] (Application Example 2)

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

[1641] In factory task management, it is necessary not only to efficiently manage task progress but also to incorporate the recognition of workers' emotions to reduce stress and fatigue. Many conventional task management systems focus on progress and deadlines, failing to consider the emotional state of workers. This can lead to accumulated stress and fatigue, potentially resulting in decreased work efficiency and increased errors. Furthermore, the lack of a method to understand the emotional dynamics of the entire team makes it difficult for managers to take appropriate measures. To address these challenges, a comprehensive task management system that incorporates emotion recognition is necessary.

[1642] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying delays in task progress, means for performing emotion recognition based on operator status information, and means for providing notifications and suggestions based on the results of emotion recognition. This makes it possible to integrate task progress management and operator emotion management. In addition to checking progress and detecting delays early, it is possible to recognize the operator's stress level and take appropriate measures, which is expected to improve work efficiency and reduce errors. Furthermore, by displaying the emotional trends of the entire team, managers can take countermeasures at the appropriate time. This can improve overall work efficiency and operator satisfaction.

[1643] "Task creation" refers to the process where a user inputs new work content and its details into the system, and the system generates a new work item based on that input.

[1644] "Task updating" refers to the process where a user inputs the content and progress of already created work items, and the system then modifies or adds information to the corresponding work items based on that input.

[1645] "Visualization of progress" means that the system displays the progress status of current work items in a format that allows for visual confirmation (e.g., Gantt chart or calendar format).

[1646] "Detection of progress delays" means that the system automatically determines whether a work item is behind schedule.

[1647] "Notification" refers to the system informing users of progress delays or important information via methods such as email or push notifications.

[1648] "Operator status information" refers to information that the worker inputs into the system, such as their work environment, work content, actions, and voice.

[1649] "Emotion recognition" refers to a system analyzing and determining an operator's emotional state based on their voice, actions, and other factors.

[1650] "Notifications and suggestions" refer to the system providing necessary warnings and action suggestions to the operator based on the results of emotion recognition.

[1651] A "generative AI model" refers to artificial intelligence that uses algorithms and networks trained through machine learning to analyze and generate emotional states and other information based on input data.

[1652] An "operator" is a user who uses a system to perform tasks.

[1653] "Team-wide emotional trends" refers to the trend in the overall emotional state of the team, obtained by analyzing emotional data collected from multiple operators.

[1654] The present invention is a task management system that integrates emotion recognition and performs comprehensive task management that takes into account the emotional state of the operator. This system includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of the risk of progress delays, means for performing emotion recognition based on the operator's status information, and means for making notifications and suggestions based on the results of emotion recognition.

[1655] Hardware and software to be used

[1656] The system configuration includes the following hardware and software:

[1657] Hardware: Industrial robots (e.g., robotic arms), smart displays, audio input devices, microphones.

[1658] Software: Python programs, EmotionEngine module, emotion recognition module, task management server API.

[1659] Overview of program processing

[1660] Task creation and update

[1661] The user inputs new work details into the robot within the factory, converts the information into JSON format, and sends it to the task management server. The server stores the task information in a database and generates new tasks. The progress of the created tasks is updated when the user inputs the information through the robot and sends it to the server.

[1662] Task visualization

[1663] Users can check the progress of tasks in real time via devices such as smart displays. All task information is received from the server in JSON format and visually displayed in Gantt charts and calendar formats.

[1664] Risk notification

[1665] The server periodically retrieves task progress information from the database and determines the risk of delays. The determined risk is communicated to the user through various means, including email and push notifications.

[1666] emotion recognition

[1667] An emotion recognition module is used to recognize the emotional state of the operator from their voice and actions while they perform their tasks. The EmotionEngine module analyzes the voice data collected by the robot and evaluates stress levels and satisfaction levels.

[1668] Emotion-based notifications and suggestions

[1669] Based on the assessed emotional state, the system provides the operator with appropriate notifications and suggestions. If the emotional recognition results indicate a high stress level, for example, a suggestion such as "Please take a break" will be sent via the robot.

[1670] Displaying sentiment data

[1671] Emotional data is analyzed on the server, and a function is provided to display the emotional trends of the entire team. This allows administrators to understand the team's emotional state and take appropriate measures.

[1672] Specific example

[1673] 1. Specific examples of creating and updating tasks:

[1674] An operator voice-inputs the task "factory machine maintenance" into the robot and sets the deadline as November 30, 2023. This information is converted to JSON format and sent to the server to generate a new task. When the task progress reaches 50%, the operator inputs the progress into the robot, and the updated information is sent to the server.

[1675] 2. Specific examples of emotion recognition and notification:

[1676] If an operator says "I'm tired" during work, the robot collects the audio, and an emotion recognition module evaluates the stress level. If the evaluation is high, the robot notifies the operator to "take a break."

[1677] 3. Specific examples of emotional data analysis:

[1678] The server analyzes emotional data collected from multiple operators and displays a result to the administrator indicating that "the team's stress level is high." The administrator then takes action based on this result.

[1679] Examples of prompts to input into a generative AI model:

[1680] "Please create a notification message for when a task is behind schedule."

[1681] "Generate suggestions for operators based on emotion recognition."

[1682] "Please generate a report showing the overall sentiment trends of the team."

[1683] This system integrates task progress management with worker emotional management, thereby improving work efficiency and overall satisfaction within the factory.

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

[1685] Step 1: Create a task

[1686] The user provides voice input to the robot specifying the details of a new task and its deadline. The robot converts this information into text and formats it into JSON format. For example, the input data might be "Task Name: 'Factory Machine Maintenance', Deadline: '2023-11-30'". The JSON data is sent to the server, which stores this data in its database and generates a new task.

[1687] Step 2: Update the task

[1688] The user inputs the work progress into the robot via voice. The robot converts this progress information into text and then formats it back into JSON format. The input data is, for example, "Task ID: '123', Progress: '50%'". The data converted to JSON format is sent to the server, which updates the database with information about the corresponding task.

[1689] Step 3: Visualize the task

[1690] The user sends a request from their device to the server to check the progress of their tasks. The server retrieves information on all tasks from the database and sends it back to the device in JSON format. The device parses the received data and displays it in a Gantt chart or calendar format.

[1691] Step 4: Detecting progress delays

[1692] The server periodically retrieves task progress information from the database and determines if there are any delays compared to the deadline. For comparison, data such as "Task ID: '123', Current Progress: '50%', Deadline: '2023-11-30'" is used. Tasks that are behind schedule are identified, and the server notifies the user of the delay risk.

[1693] Step 5: Emotion Recognition

[1694] An operator provides voice input to the robot while performing a task. The robot collects this voice data and sends it to an emotion recognition module. The emotion recognition module analyzes the voice data and determines the emotional state. An example of the input data is "audio data: 'audio_sample.wav'". The determined emotional state is output as a numerical value, such as a stress level.

[1695] Step 6: Emotion-based notifications and suggestions

[1696] Based on the emotional state data received from the emotion recognition module, the server generates necessary notifications and suggestions for the operator. If the emotional data indicates a "high stress level," the server notifies the operator to "take a break." Specific notification content, such as "recommendation to take a break," is generated, and the robot communicates this information to the operator via voice.

[1697] Step 7: Displaying emotion data

[1698] The server analyzes emotional data collected from multiple operators to visualize the emotional trends of the entire team. The analyzed data is sent to terminals and displayed on smart displays, etc. For example, the displayed content might be "Team-wide stress level: 'High'". This allows administrators to understand the emotional state of the entire team.

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

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

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

[1702] [Fourth Embodiment]

[1703] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[1704] As shown in Figure 7, the data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

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

[1706] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

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

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

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

[1710] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[1711] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

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

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

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

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

[1716] This invention is a system that manages tasks created and updated by users, visualizes the progress of tasks, detects delay risks, and provides timely notifications. The implementation of this system is described below.

[1717] Task creation and update

[1718] When a user creates a task, they first enter the task details (task name, due date, assignee, dependent tasks, etc.) from their device. The device then sends this information to the task management server in JSON format. The server saves the received data to its database, and a new task is created. For example, a user can create a task called "Design Project X" and set its due date to October 10, 2023.

[1719] When a user updates the progress of a task, they enter the current progress percentage (e.g., 50%) from their terminal and send it to the server. The server updates the progress data in the database and reflects the information in other tasks related to that task. For example, a user can set the progress of "Design Project X" to 50%.

[1720] Task visualization

[1721] To check the progress of tasks, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device visualizes the retrieved task information in a format such as a Gantt chart or calendar. This makes it easier for the user to see the progress of all tasks at a glance. For example, the progress of "Project X Design" is displayed as 50% on the Gantt chart.

[1722] Risk notification

[1723] To detect the risk of tasks falling behind schedule, the server periodically monitors the progress of all tasks. The server compares the progress of tasks with their deadlines to identify tasks that are at risk of not meeting their deadlines. This risk assessment is based on the remaining time and the required progress. For example, if task "Development of Project Y" is 20% complete and its deadline is November 1, 2023, the server will determine that this task is behind schedule.

[1724] If a delay risk is detected, the server sends a notification to the person in charge of the relevant task via email or push notification. This allows the person in charge to take immediate action. For example, the server sends a notification to the person in charge of "Development of Project Y" stating, "Task 'Development of Project Y' is likely to be delayed."

[1725] These features allow users to eliminate wasted time on progress checks, manage tasks efficiently, and detect and address risks early. The system of this invention automates, visualizes, and provides timely notifications for task management, thereby improving operational efficiency and avoiding risks.

[1726] The following describes the processing flow.

[1727] Task creation and update

[1728] Task creation

[1729] Step 1:

[1730] The user enters task details (task name, due date, assignee, dependent tasks, etc.) on their device. This information is entered as a form.

[1731] Step 2:

[1732] The terminal converts the entered task information into JSON format and sends a POST request to the task management server.

[1733] Step 3:

[1734] The server parses the received request and extracts task information.

[1735] Step 4:

[1736] The server saves task information to the database. A task ID is also issued for newly created tasks.

[1737] Step 5:

[1738] The server verifies that the task was created successfully and returns a success message to the terminal.

[1739] Task update

[1740] Step 1:

[1741] To update the progress, the user enters the task's progress percentage (e.g., 50%) on their device.

[1742] Step 2:

[1743] The terminal converts the update information into JSON format and sends a PUT request to the task management server.

[1744] Step 3:

[1745] The server parses the received request and extracts the target task ID and the updated progress information.

[1746] Step 4:

[1747] The server updates the progress information of the relevant task in the database.

[1748] Step 5:

[1749] The server confirms that the task progress has been successfully updated and returns a success message to the terminal.

[1750] Task visualization

[1751] Step 1:

[1752] To check the progress of all tasks, the user requests task information on their device. This is sent as a GET request to the server.

[1753] Step 2:

[1754] The server retrieves progress information for all tasks from the database.

[1755] Step 3:

[1756] The server converts the acquired task information into JSON format and sends it back to the terminal.

[1757] Step 4:

[1758] The terminal analyzes the received task information and displays it to the user in a Gantt chart or calendar format.

[1759] Risk notification

[1760] Step 1:

[1761] The server periodically retrieves progress information for all tasks from the database and compares it with the task deadlines.

[1762] Step 2:

[1763] The server compares progress with deadlines and identifies tasks that may not be completed by the deadline.

[1764] Step 3:

[1765] The server retrieves the information of the person responsible for the identified risk task and generates a notification indicating a risk of delay.

[1766] Step 4:

[1767] The server sends the generated notification content to the responsible person's terminal via email or push notification.

[1768] Step 5:

[1769] The device displays received notifications to the user and informs them about the risk of delays.

[1770] (Example 1)

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

[1772] Traditional task management systems had problems with efficiently creating and updating tasks, visualizing progress, and notifying users of delay risks. In particular, when multiple tasks were dependent on each other or in large-scale projects, it was difficult to grasp progress in real time and detect delay risks early, which raised concerns about a decrease in overall work efficiency.

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

[1774] In this invention, the server includes means for the user to input detailed task information, means for transmitting the input information to the server, means for the server to store the received information in a database, means for the user to update the task progress, means for transmitting the progress data to the server, means for the server to update the database with the received progress data, means for the user to send a request to retrieve task information, means for the server to retrieve all task information from the database and send it back to the terminal, means for the terminal to visualize the received task information, means for the server to periodically monitor the task progress and evaluate the risk of delay, and means for notifying the evaluation results. This enables real-time task management and visualization of progress, as well as rapid detection and notification of delay risks.

[1775] A "user" refers to an individual or legal entity that uses the system to create tasks, update their progress, or check their progress.

[1776] A "terminal" refers to an electronic device used by a user to input information or display data from a server.

[1777] A "server" refers to a computing system used for managing task information, storing data, monitoring progress, and providing notifications.

[1778] A "database" refers to an information management system used by a server to store task information and progress data.

[1779] A "task" refers to a series of actions or activities that a user creates to achieve a specific objective.

[1780] "Progress status" refers to information indicating the extent to which a task has been completed.

[1781] "Visualization" refers to the process of displaying the progress of a task in an easy-to-understand way for the user.

[1782] "Risk" refers to a situation where the progress of a task may fall behind schedule.

[1783] "Notification" refers to a means of communication used by a server to inform the person in charge of a task about the risk of delays.

[1784] "JSON format" is an abbreviation for JavaScript Object Notation, and refers to a lightweight data exchange format for structurally representing data.

[1785] This invention provides a system for efficiently managing user-created and updated tasks, visualizing progress, and detecting and notifying users of delay risks at an early stage. The configuration for implementing this system is described below.

[1786] Task creation and update

[1787] The user first enters task details (task name, due date, assignee, dependent tasks, etc.) into the terminal. This information is converted to JSON format and sent to the task management server. The server saves the received data to its database, and a new task is created. For example, a user might create a task called "Design Project X" and set the due date to October 10, 2023. When the user updates the task's progress, they enter the progress percentage (e.g., 50%) from the terminal and send it to the server. The server saves the received progress data to its database and reflects the information in other tasks related to that task. For example, a user might set the progress of "Design Project X" to 50%.

[1788] Task visualization

[1789] To check the progress of a task, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device visualizes the retrieved task information in a format such as a Gantt chart or calendar, allowing the user to see the progress of all tasks at a glance. For example, the progress of "Project X Design" may be displayed as 50% on the Gantt chart.

[1790] Risk notification

[1791] The server periodically monitors the progress of all tasks, comparing progress with deadlines to assess the risk of delay. This assessment is based on the remaining time and required progress, and if there is a risk of delay, the server sends a notification to the person in charge of the task via email or push notification. For example, if task "Development of Project Y" is 20% complete and due on November 1, 2023, the server will determine that this task is behind schedule and send a notification to the person in charge stating, "Task 'Development of Project Y' is likely to be delayed."

[1792] These features allow users to eliminate wasted time on progress checks, manage tasks efficiently, and detect and address risks early. The system of this invention automates, visualizes, and provides timely notifications for task management, thereby improving operational efficiency and avoiding risks.

[1793] Command example

[1794] By using a generative AI model, you can receive explanations and help for each function by entering prompts like the following.

[1795] Examples of prompts for a generative AI model:

[1796] Please explain each function of the following task management system in clear, natural language.

[1797] Task creation and update

[1798] When a user creates a task, they enter the task details (task name, due date, assignee, dependent tasks, etc.) from their device. The device sends this information to the task management server in JSON format. The server saves the received data to its database, and a new task is created.

[1799] Example: A user creates a task called "Design Project X" and sets the deadline to October 10, 2023.

[1800] When a user updates the progress of a task, they enter the current progress percentage (e.g., 50%) from their device and send it to the server. The server updates the progress data in the database and reflects the information in other tasks related to that task.

[1801] Specific example: The user sets the progress of "Project X Design" to 50%.

[1802] Task visualization

[1803] To check the progress of their tasks, the user sends a request from their device to the server to retrieve all tasks. The server retrieves the task information from the database and returns it to the device in JSON format. The device then visualizes the retrieved task information in a format such as a Gantt chart or calendar.

[1804] Specific example: The progress of "Project X Design" is displayed as 50% on the Gantt chart.

[1805] Risk notification

[1806] The server periodically monitors the progress of all tasks to detect the risk of tasks falling behind schedule. The server compares task progress with deadlines to identify tasks at risk of missing deadlines. This risk assessment is based on the remaining time and the required progress.

[1807] Specific example: If task "Development of Project Y" is 20% complete and due on November 1, 2023, the server will determine that this task is behind schedule.

[1808] If a delay risk is detected, the server will send a notification to the person responsible for the relevant task via email or push notification.

[1809] Specific example: The server sends a notification to the person in charge of "Development of Project Y" stating, "Task 'Development of Project Y' is likely to be delayed."

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

[1811] Step 1:

[1812] The user enters the task details.

[1813] The user uses their device to enter details about the new task (task name, due date, assignee, dependent tasks, etc.).

[1814] Input: User-entered task name "Project X Design", deadline "October 10, 2023", assignee "Taro Yamada", dependent task "Project W Review", etc.

[1815] Data processing: The terminal converts the entered information into JSON format.

[1816] Output: Task information in JSON format: "{'taskName': 'Project X Design', 'deadline': '2023-10-10', 'assignee': 'Taro Yamada', 'dependency': 'Project W Review'}".

[1817] Step 2:

[1818] The device sends task data to the server.

[1819] The terminal sends the converted JSON-formatted task information to the task management server.

[1820] Input: Task information in JSON format.

[1821] Data processing: None (simple data transfer).

[1822] Output: Task information sent to the server.

[1823] Step 3:

[1824] The server saves the task information it receives to the database.

[1825] The server saves the received task information to the database and registers it as a new task.

[1826] Input: Received task information in JSON format.

[1827] Data processing: Convert the data to a format suitable for the database and save it as a new record in the database.

[1828] Output: A new task record added to the database.

[1829] Step 4:

[1830] The user enters the task progress.

[1831] The user uses their device to input the progress of an existing task (e.g., 50%).

[1832] Input: User-entered task name "Project X Design", progress "50%".

[1833] Data processing: The terminal converts the entered information into JSON format.

[1834] Output: Progress information in JSON format: "{'taskName': 'Project X Design', 'progress': 50}".

[1835] Step 5:

[1836] The device sends progress data to the server.

[1837] The terminal sends the converted JSON-formatted progress information to the task management server.

[1838] Input: Progress information in JSON format.

[1839] Data processing: None (simple data transfer).

[1840] Output: Progress information sent to the server.

[1841] Step 6:

[1842] The server updates the database with progress information.

[1843] The server saves the received progress information to the database and updates the progress status of the relevant task. It also reflects the information in other tasks related to that task.

[1844] Input: Received progress information in JSON format.

[1845] Data processing: Update the progress of the relevant task in the database. Also update related tasks.

[1846] Output: Updated task records in the database.

[1847] Step 7:

[1848] A user submits a request to retrieve task information.

[1849] The user uses their terminal to send a request to the server to retrieve information about all tasks.

[1850] Input: Task information retrieval request.

[1851] Data processing: None (simple request).

[1852] Output: The request sent to the server.

[1853] Step 8:

[1854] The server retrieves task information from the database.

[1855] The server retrieves information on all tasks from the database and converts it to JSON format.

[1856] Input: Task information retrieval request.

[1857] Data processing: Execute database queries to retrieve task information and convert it to JSON format.

[1858] Output: Task information in JSON format.

[1859] Step 9:

[1860] The server sends task information back to the terminal.

[1861] The server returns the converted task information in JSON format to the terminal.

[1862] Input: Task information in JSON format.

[1863] Data processing: None (simple data transfer).

[1864] Output: Task information sent to the terminal.

[1865] Step 10:

[1866] The device visualizes task information.

[1867] The device uses the received task information to visualize it in a Gantt chart or calendar format.

[1868] Input: Received task information in JSON format.

[1869] Data processing: Convert task information into Gantt charts and calendar formats.

[1870] Output: Displayed task information (e.g., "Project X Design" progress: 50%).

[1871] Step 11:

[1872] The server monitors the progress of the task.

[1873] The server periodically retrieves the progress of all tasks from the database, compares the progress with the deadline, and assesses the risk of delays.

[1874] Input: All task information in the database.

[1875] Data processing: Compare progress with deadlines and assess the risk of delays.

[1876] Output: Delay risk assessment results.

[1877] Step 12:

[1878] The server will notify you of the risk of delay.

[1879] The server sends notifications via email or push notification to the person responsible for the task where a delay risk has been identified.

[1880] Input: Delay risk assessment results.

[1881] Data processing: Generate and send a notification message.

[1882] Output: Notification sent to the person in charge (e.g., "Task 'Development of Project Y' is likely to be delayed.").

[1883] (Application Example 1)

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

[1885] Traditional task management systems required users to use desktop or mobile devices to create tasks, update progress, and receive notifications about delay risks, resulting in cumbersome manual data entry. Furthermore, they often lacked real-time visualization of progress and risk notifications, making quick responses difficult.

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

[1887] In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of delays in task progress, means for inputting tasks and updating their progress using smart glasses, means for visualizing the progress displayed on the smart glasses, and means for notifying the smart glasses of delay risks. This enables users to manage tasks hands-free, check progress and risks in real time, and take quick countermeasures.

[1888] "Means for creating and updating tasks" refers to a function that allows users to input new tasks and send detailed information about those tasks to the server for storage in the database.

[1889] "Means of visualizing task progress" refers to a function where the server retrieves task information from a database and displays it in a format that is easy for the user to understand visually.

[1890] "A means of detecting and notifying about delays in task progress" refers to a function in which the server compares the progress and deadline of a task, identifies tasks at risk of delay, and notifies the user of that information.

[1891] "A means of inputting tasks and updating progress using smart glasses" refers to a function that allows users to input detailed task information and progress using voice commands or gestures through smart glasses, and to send that information to a server.

[1892] "Means of visualizing progress displayed on smart glasses" refers to a function that displays the progress of tasks on the smart glasses' screen in the form of a Gantt chart or calendar.

[1893] "A means of providing delay risk notifications to smart glasses" refers to a function that displays delay risk notifications sent from the server on smart glasses, enabling users to respond quickly.

[1894] Modes for carrying out the invention

[1895] This invention is a system that manages tasks created and updated by users, visualizes the progress of tasks, detects delay risks, and provides timely notifications. Specific embodiments thereof are described below.

[1896] Task creation and update

[1897] When a user creates a task, they input task details (task name, due date, assignee, dependent tasks, etc.) into the smart glasses using voice commands or gestures. The smart glasses send this information to the task management server in JSON format, and the server stores the received data in its database and creates a new task. For example, a user can create a task called "Design a New Project" and set the due date to a specific date.

[1898] To update task progress, the user similarly inputs the current progress level into their smart glasses using voice commands or gestures and sends it to the server. The server updates the progress data in its database and reflects the information in other tasks related to that task. For example, a user can set the progress of "Design a New Project" to 50%.

[1899] Task visualization

[1900] To check the progress of tasks, the user sends a request to the server via smart glasses to retrieve all tasks. The server retrieves task information from the database and returns it to the smart glasses in JSON format. The progress of tasks is displayed on the smart glasses' screen in the form of a Gantt chart or calendar. This makes it easy for the user to see the progress of all tasks at a glance. For example, the progress of "Designing a New Project" is displayed on the Gantt chart.

[1901] Risk notification

[1902] To detect the risk of tasks falling behind schedule, the server periodically monitors the progress of all tasks. The server compares the progress of tasks with their deadlines to identify tasks that are at risk of not being met. This risk assessment is based on the remaining time and the required progress. For example, if a task is 20% complete and has a deadline of a specific date, the server will determine that this task is behind schedule.

[1903] If a delay risk is detected, the server sends a push notification to the smart glasses, displaying the notification to the person responsible for the relevant task. This allows the person responsible to take immediate action. For example, the server might send a notification to the person responsible for "Designing a New Project" stating, "This task is likely to be delayed."

[1904] Specific example

[1905] For example, consider a task management scenario in a factory. The user (worker) wears smart glasses and inputs the next task using voice or gestures. The worker can create a new task, such as "check the assembly line," and update its progress in real time. The server monitors the task's progress and sends a notification to the smart glasses if the progress is behind schedule despite the approaching deadline, alerting the user to the risk.

[1906] Example of a prompt

[1907] Please enter the task details. Include the task name, due date, assignee, and dependent tasks.

[1908] This system allows users to manage tasks effortlessly and perform their work efficiently. It also enables early detection of risks and prompt action.

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

[1910] Step 1:

[1911] The user inputs task details into smart glasses using voice commands or gestures. This includes information such as the task name, due date, assignee, and dependent tasks. The smart glasses convert this information into JSON format and send it to the task management server.

[1912] Input: Enter task details (task name, due date, assignee, dependent tasks) using voice or gestures.

[1913] Processing: Smart glasses analyze voice or gestures and convert them into JSON format.

[1914] Output: Task information converted to JSON format is sent to the server.

[1915] Step 2:

[1916] The server saves the received task information to the database and creates a new task. The server parses the JSON data and writes it to the database in the appropriate format.

[1917] Input: Task information in JSON format.

[1918] Processing: The server parses the JSON and saves it to the database.

[1919] Output: A new task is added to the database.

[1920] Step 3:

[1921] The user updates task progress via smart glasses. Progress is entered via voice or gestures, and the smart glasses convert this into JSON format and send it to the server.

[1922] Input: Enter the progress percentage (e.g., 50%) using voice or gestures.

[1923] Processing: The smart glasses analyze the input and convert it to JSON format.

[1924] Output: Sends progress information in JSON format to the server.

[1925] Step 4:

[1926] The server updates the database with the received progress information, and the progress is reflected in the relevant task and related tasks. The server analyzes the progress information and updates the progress of the relevant task.

[1927] Input: Progress information in JSON format.

[1928] Processing: The server parses the JSON and updates the progress of the corresponding task in the database.

[1929] Output: Task information in the database is updated.

[1930] Step 5:

[1931] The user uses smart glasses to check the progress of all tasks. A request to retrieve all tasks is sent from the smart glasses to the server.

[1932] Input: A request to check the progress of all tasks.

[1933] Processing: The server retrieves task information from the database and sends it back to the smart glasses in JSON format.

[1934] Output: Task information in JSON format is sent to the smart glasses.

[1935] Step 6:

[1936] The smart glasses display received task information in Gantt chart and calendar formats. This allows users to check the progress of all tasks hands-free.

[1937] Input: Task information in JSON format.

[1938] Processing: Smart glasses parse the JSON data and convert it into a Gantt chart or calendar for display.

[1939] Output: Visualized task progress is displayed on the smart glasses' screen.

[1940] Step 7:

[1941] The server periodically monitors the progress of tasks and detects tasks at risk of delay. The server compares the progress with the deadline to make a determination.

[1942] Input: Task progress information and deadline information from the database.

[1943] Processing: The server compares progress and deadlines to identify tasks at risk of delay.

[1944] Output: Delay risk assessment result.

[1945] Step 8:

[1946] When a delay risk is detected, the server sends a push notification to the smart glasses, displaying the notification to the person responsible for the relevant task. This allows the user to take immediate action.

[1947] Input: Delay risk assessment result.

[1948] Processing: The server generates a push notification and sends it to the smart glasses.

[1949] Output: A delay risk notification is displayed on the smart glasses.

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

[1951] This invention provides a more efficient and satisfying work environment by combining a task management system with an emotion engine, enabling notifications and task management based on the user's emotions. This system includes means for creating and updating tasks, means for visualizing progress, means for detecting and notifying of delays in progress, and an emotion engine that recognizes the user's emotions.

[1952] Task creation and update

[1953] Task creation:

[1954] The user enters task details on their device. The device converts this information into JSON format and sends it to the task management server. The server stores the task information in its database and generates a new task.

[1955] Task update:

[1956] The user enters the progress status on the terminal, and the terminal converts this information into JSON format and sends it to the server. The server updates the progress information for the corresponding task in the database.

[1957] Task visualization

[1958] The user sends a request from their device to the server to check the progress of all tasks. The server retrieves information on all tasks from the database and sends it back to the device in JSON format. The device then parses the task information and displays it in a Gantt chart or calendar format.

[1959] Risk notification

[1960] The server periodically retrieves progress information for all tasks from the database and compares it with task deadlines. By comparing progress and deadlines, it identifies tasks that are likely to not be completed on time. Assignees of identified risk tasks are notified of the delay risk via email or push notification.

[1961] Emotional Engine

[1962] Emotion recognition:

[1963] The server analyzes user input data, operation history, and other relevant data to recognize the user's emotions. The emotion engine uses machine learning models to determine the user's emotional state (e.g., stress, satisfaction, anxiety). Information as the user enters or updates tasks is also sent to the emotion engine and used for analysis.

[1964] Emotion-based notifications:

[1965] The emotion engine analyzes the user's emotional state and generates notifications tailored to that specific emotional state. For example, if the user is feeling stressed, the server will notify them with a suggestion to "relax." Similarly, if there is a high risk of delays, the server will provide a notification that takes the user's emotional state into consideration.

[1966] Displaying sentiment data:

[1967] The server also analyzes emotional data collected from multiple users and provides a function to display the emotional trends of the entire team. This allows administrators to understand the emotional state of the entire team and take necessary actions. For example, if many team members are experiencing stress, the server will provide this information to the administrator and suggest countermeasures.

[1968] Specific example

[1969] Example 1:

[1970] A user creates a task called "Design Project A" and sets the deadline to November 30, 2023. If progress starts to fall behind, the server detects this and notifies the user. At the same time, if the emotion engine determines that the user's stress level is high, it also makes suggestions for stress reduction.

[1971] Example 2:

[1972] In projects involving multiple team members, if overall progress is behind schedule, the server uses an emotion engine to analyze the emotional state of all team members. It then provides the results to the administrator and suggests appropriate actions.

[1973] These features allow the task management system to not only manage task progress but also contribute to managing user emotions, thereby improving overall work efficiency and user satisfaction. The system of this invention realizes a more human-centered task management environment by taking user emotions into consideration.

[1974] The following describes the processing flow.

[1975] Task creation and update

[1976] Task creation

[1977] Step 1:

[1978] The user enters details of a new task on their device. Specifically, they use a form to enter items such as the task name, due date, assignee, and dependent tasks.

[1979] Step 2:

[1980] The terminal converts the entered task information into JSON format and sends a POST request to the task management server.

[1981] Step 3:

[1982] The server parses the received request and extracts task information.

[1983] Step 4:

[1984] The server saves task information to the database. At the same time, it generates an ID for the newly created task.

[1985] Step 5:

[1986] The server confirms that the task was created successfully and sends a success message and a new task ID back to the terminal.

[1987] Task update

[1988] Step 1:

[1989] Users update the task progress by entering the progress percentage (e.g., 50%) on their device. Use an update form or interactive element.

[1990] Step 2:

[1991] The terminal converts the progress information into JSON format and sends a PUT request to the task management server.

[1992] Step 3:

[1993] The server analyzes the received request and extracts the target task ID and progress information.

[1994] Step 4:

[1995] The server updates the progress information of the relevant task in the database.

[1996] Step 5:

[1997] The server confirms that the task progress has been successfully updated and sends a success message back to the terminal.

[1998] Task visualization

[1999] Step 1:

[2000] To check the progress of all tasks, the user requests task information on their device. This is sent as a GET request to the server.

[2001] Step 2:

[2002] The server retrieves progress information for all tasks from the database.

[2003] Step 3:

[2004] The server converts the acquired task information into JSON format and sends it back to the terminal.

[2005] Step 4:

[2006] The terminal analyzes the received task information and displays it to the user in a Gantt chart or calendar format.

[2007] Risk notification

[2008] Step 1:

[2009] The server periodically retrieves progress information for all tasks from the database and compares it with the task deadlines.

[2010] Step 2:

[2011] The server compares progress with deadlines and identifies tasks that may not be completed by the deadline.

[2012] Step 3:

[2013] The server retrieves the information of the person responsible for the identified risk task and generates a notification indicating a risk of delay.

[2014] Step 4:

[2015] The server sends the generated notification content to the responsible person's terminal via email or push notification.

[2016] Step 5:

[2017] The device displays received notifications to the user and informs them about the risk of delays.

[2018] Emotional Engine

[2019] Step 1:

[2020] The server periodically collects user input data and operation history, and analyzes it using an emotion engine.

[2021] Step 2:

[2022] The emotion engine uses machine learning models to determine the user's emotional state based on collected data. For example, it can identify stress levels, satisfaction levels, and so on.

[2023] Step 3:

[2024] When a user enters or updates a task, data from the device is sent to the sentiment engine and used for sentiment analysis.

[2025] Step 4:

[2026] The emotion engine generates appropriate notifications for the user based on the determined emotional state. For example, if the user is experiencing high stress, it will suggest relaxation techniques.

[2027] Step 5:

[2028] The server sends the generated notification content to the user's device via email or push notification.

[2029] Step 6:

[2030] The server analyzes the emotional data of multiple users and generates data to display the emotional trends of the entire team.

[2031] Step 7:

[2032] Administrators can monitor the emotional state of the entire team through their devices and take necessary measures. For example, if many members are experiencing high levels of stress, they can use that information to provide support.

[2033] (Example 2)

[2034] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[2035] Traditional task management systems can track task progress and notify users of delays, but they lack the ability to consider users' emotional states, making efficient task management difficult. In particular, ignoring emotional factors such as user stress and satisfaction can hinder task progress. Furthermore, the lack of means for managers to understand the emotional dynamics of the entire team makes appropriate responses difficult.

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

[2037] In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of delays in task progress, means for recognizing user emotions and notifying based on the analysis results, and means for analyzing user and multiple user emotion data and presenting it to the administrator. This enables efficient and highly satisfying task management that takes into account the emotional state of users.

[2038] A "task" refers to a unit of work or task that a user performs to achieve a specific objective.

[2039] "Means" refers to the methods or mechanisms that a system uses to achieve a specific function.

[2040] A "server" refers to a computer system that provides or processes data in response to requests from clients.

[2041] A "terminal" refers to a device that a user uses to access and operate a system. Examples include personal computers, smartphones, and tablets.

[2042] "Users" refer to the people who use this system to create, update, and manage tasks.

[2043] "Means for creating and updating tasks" refers to a system that provides users with the functionality to create new tasks and modify information about existing tasks.

[2044] "Means of visualizing task progress" refers to a system that provides a function to visually display the progress of tasks. For example, it can be displayed in a Gantt chart or calendar format.

[2045] "Means for detecting and notifying about delays in task progress" refers to a system that compares the progress of a task with its deadline and provides a function to notify the user if there is a risk of delay.

[2046] "A means of recognizing user emotions and providing notifications based on the analysis results" refers to a system that analyzes user input data and operation history, recognizes the user's emotional state, and provides a function to generate notifications corresponding to specific emotional states.

[2047] "Means of analyzing and presenting emotional data of users or multiple users to administrators" refers to a system that provides functions for collecting and analyzing emotional data of users or entire teams and providing the results to administrators.

[2048] "Notification" refers to a means by which a system communicates information to a user. Specifically, this includes email and push notifications.

[2049] "Visualization" refers to the visual display of data and information. This includes, for example, displaying data using graphs and charts.

[2050] An "emotion engine" refers to a software component that includes a machine learning model for analyzing and recognizing a user's emotional state.

[2051] A "machine learning model" refers to an algorithm that learns from large amounts of data and uses that data to perform inferences and predictions.

[2052] This invention is a task management system that takes user emotions into consideration, and by providing means for creating and updating tasks, means for visualizing progress, means for detecting and notifying of progress delays, and an emotion engine, it provides an efficient and highly satisfying work environment.

[2053] Task creation and update

[2054] Task creation:

[2055] The user enters details such as the task name, due date, and description into a task creation form on their device. This detailed information is converted to JSON format by the device and sent to the server. The server parses the received JSON data and saves it as a new task in the database. For example, if a user creates a task called "Design Project A" and sets the due date to November 30, 2023, the device converts this information to JSON format and sends it to the server via an HTTP POST request.

[2056] Task update:

[2057] The user enters the progress status of an existing task (e.g., 50%) on their device. This information is also converted to JSON format by the device and sent to the server. The server reflects the received progress information in the corresponding task in the database and updates the progress status.

[2058] Task visualization

[2059] When a user sends a request from their device to check the progress of all tasks, the server retrieves information on all tasks from the database and sends it back in JSON format. The device then parses the received JSON data and displays it visually in a Gantt chart or calendar format. This allows the user to grasp the progress of each task at a glance.

[2060] Risk notification

[2061] The server periodically retrieves progress information for all tasks from the database and compares the progress with the deadline. If a task is found to be behind schedule, the server notifies the task's assignee of the delay risk via email or push notification. For example, if a task due on November 30, 2023, is less than 20% complete, it will be flagged as a risk task and the assignee will be notified.

[2062] Emotional Engine

[2063] Emotion recognition:

[2064] The server collects user input data and operation history, and uses an emotion engine to analyze the user's emotional state. The emotion engine uses machine learning models to determine the user's stress, satisfaction, and anxiety levels. For example, if the frequency of task updates is low and there are signs of anxiety in the operation history, the server will determine that the user's stress level is high.

[2065] Emotion-based notifications:

[2066] Based on the emotion engine's analysis of the user's emotional state, the server generates notifications tailored to that specific emotional state. For example, if the user is feeling stressed, it sends a notification suggesting a break to relax.

[2067] Displaying sentiment data:

[2068] The server analyzes the emotional data collected from multiple users and presents the overall emotional trends of the team to the administrator. This allows the administrator to understand the emotional state of the entire team and take necessary actions. For example, if many team members are experiencing stress, this information is provided to the administrator, and countermeasures are suggested.

[2069] Specific example

[2070] Example 1:

[2071] A user creates a task called "Design Project A" and sets the deadline to November 30, 2023. If progress starts to fall behind, the server detects this and notifies the user. At the same time, if the emotion engine determines that the user's stress level is high, it also makes suggestions for stress reduction.

[2072] Example 2:

[2073] In projects involving multiple team members, if overall progress is behind schedule, the server uses an emotion engine to analyze the emotional state of all team members. It then provides the results to the administrator and suggests appropriate actions.

[2074] Example of a prompt

[2075] "Create a design task for Project A and set the deadline to November 30, 2023."

[2076] "Please update the progress of the design task for Project A to 50%."

[2077] "Please show the progress of all tasks."

[2078] "Please check for any progress risks in tasks with approaching deadlines, and notify us if any risks exist."

[2079] "Determine the user's emotional state based on their activity history."

[2080] "Please create a notification for when a user's stress level is high."

[2081] "Analyze the emotional state of the entire team and notify the manager."

[2082] Thus, the system of the present invention, in addition to conventional task management functions, utilizes an emotion engine to manage tasks while taking into account the user's emotional state, thereby improving operational efficiency and user satisfaction.

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

[2084] Step 1:

[2085] The user enters the task details.

[2086] Input: The user enters details such as the task name "Design Project A," deadline, and description into the task creation form on their device.

[2087] Operation: When the user clicks the input button, the form data on the device is retrieved.

[2088] Output: The retrieved data is ready to be converted to JSON format.

[2089] Step 2:

[2090] The terminal converts the task details into JSON format.

[2091] Input: Task details entered by the user.

[2092] Operation: The terminal generates JSON data like the following.

[2093] json

[2094] {

[2095] "Task name": "Design for Project A",

[2096] "Deadline": "2023-11-30",

[2097] "Description": "Creating design documents"

[2098] }

[2099] Output: Task details data converted to JSON format.

[2100] Step 3:

[2101] The device sends data in JSON format to the server.

[2102] Input: Task details data converted to JSON format.

[2103] Operation: The terminal sends data to the server as an HTTP POST request.

[2104] Output: JSON data sent to the server.

[2105] Step 4:

[2106] The server receives task details data and saves it to the database.

[2107] Input: JSON data sent from the device.

[2108] Operation: The server parses the received data and saves it to the database as a new task. The server generates a task ID and adds it to the database.

[2109] Output: New task information saved in the database.

[2110] Step 5:

[2111] The server notifies that the task has been created.

[2112] Input: New task information stored in the database.

[2113] Action: The server generates a response indicating that the task was successfully created and sends it back to the terminal.

[2114] Output: A task creation completion notification is displayed on the device.

[2115] Step 6:

[2116] The user enters the progress status of existing tasks.

[2117] Input: The user enters "Project A design task progress: 50%" into the progress update form on the device.

[2118] Operation: When the user clicks the progress update button, the form data is retrieved.

[2119] Output: The retrieved progress information is ready to be converted to JSON format.

[2120] Step 7:

[2121] The device converts the progress information into JSON format.

[2122] Input: Progress information entered by the user.

[2123] Operation: The terminal generates JSON data like the following.

[2124] json

[2125] {

[2126] "Task ID": "123",

[2127] "Progress Status": "50%"

[2128] }

[2129] Output: Progress information converted to JSON format.

[2130] Step 8:

[2131] The device sends progress information data in JSON format to the server.

[2132] Input: Progress information converted to JSON format.

[2133] Operation: The terminal sends data to the server as an HTTP PUT request.

[2134] Output: JSON data sent to the server.

[2135] Step 9:

[2136] The server receives progress information and updates the database.

[2137] Input: JSON data sent from the device.

[2138] Operation: The server parses the received progress information and updates the progress status of the corresponding task in the database.

[2139] Output: Progress information of tasks updated in the database.

[2140] Step 10:

[2141] The server notifies you that the progress update is complete.

[2142] Input: Progress information of tasks updated in the database.

[2143] Operation: The server generates a response indicating that the progress has been successfully updated and sends it back to the terminal.

[2144] Output: A progress update completion notification is displayed on the device.

[2145] Step 11:

[2146] The user requests an update on the progress of all tasks.

[2147] Input: User request.

[2148] Action: The user clicks the progress check button on the device.

[2149] Output: A progress request is sent to the server.

[2150] Step 12:

[2151] The server retrieves the progress of all tasks and returns it in JSON format.

[2152] Input: Progress request from the user.

[2153] Operation: The server retrieves all task information from the database and generates JSON data like the following.

[2154] json

[2155] [

[2156] {

[2157] "Task name": "Design for Project A",

[2158] "Progress Status": "50%"

[2159] "Deadline": "2023-11-30"

[2160] },

[2161] {

[2162] "Task name": "Development of Project B",

[2163] "Progress Status": "80%"

[2164] "Deadline": "2023-12-15"

[2165] }

[2166] ]

[2167] Output: JSON data containing the progress of all tasks.

[2168] Step 13:

[2169] The device receives and visualizes progress data in JSON format.

[2170] Input: JSON data received from the server.

[2171] Operation: The device analyzes the received data and displays it in a Gantt chart or calendar format.

[2172] Output: Visualized task progress displayed on the terminal.

[2173] Step 14:

[2174] The server periodically retrieves progress information for all tasks and assesses the risks.

[2175] Input: Progress information for all tasks stored in the database.

[2176] Operation: The server periodically scans the database to compare the progress and deadlines of each task.

[2177] Output: Results of risk task identification.

[2178] Step 15:

[2179] The server notifies the responsible person of the risky task.

[2180] Input: Task information with identified risks.

[2181] Operation: The server notifies the responsible person of the risk of delay via email or push notification.

[2182] Output: Notification sent to the person in charge.

[2183] Step 16:

[2184] The server collects user emotion data and analyzes it using an emotion engine.

[2185] Input: User input data and operation history.

[2186] Operation: The server passes the collected data to the sentiment engine, which then analyzes it using a machine learning model.

[2187] Output: Analysis results of the user's emotional state.

[2188] Step 17:

[2189] The server generates notifications based on emotional state.

[2190] Input: User's emotional state analysis results.

[2191] Operation: Based on the analysis results, the server generates appropriate notifications for the user. For example, if the user is experiencing high stress levels, it will suggest ways to relax.

[2192] Output: Notifications based on emotional state.

[2193] Step 18:

[2194] The server analyzes emotional data and provides the administrator with an overview of the team's overall emotional trends.

[2195] Input: Sentiment data from multiple users.

[2196] Operation: The server analyzes emotional data and generates data that visually displays the team's stress levels, satisfaction levels, and other metrics.

[2197] Output: Team-wide sentiment trend report for administrators.

[2198] Through the above processing steps, the task management system takes into account the user's emotional state, enabling efficient and highly satisfying task management.

[2199] (Application Example 2)

[2200] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[2201] In factory task management, it is necessary not only to efficiently manage task progress but also to incorporate the recognition of workers' emotions to reduce stress and fatigue. Many conventional task management systems focus on progress and deadlines, failing to consider the emotional state of workers. This can lead to accumulated stress and fatigue, potentially resulting in decreased work efficiency and increased errors. Furthermore, the lack of a method to understand the emotional dynamics of the entire team makes it difficult for managers to take appropriate measures. To address these challenges, a comprehensive task management system that incorporates emotion recognition is necessary.

[2202] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying delays in task progress, means for performing emotion recognition based on operator status information, and means for providing notifications and suggestions based on the results of emotion recognition. This makes it possible to integrate task progress management and operator emotion management. In addition to checking progress and detecting delays early, it is possible to recognize the operator's stress level and take appropriate measures, which is expected to improve work efficiency and reduce errors. Furthermore, by displaying the emotional trends of the entire team, managers can take countermeasures at the appropriate time. This can improve overall work efficiency and operator satisfaction.

[2203] "Task creation" refers to the process where a user inputs new work content and its details into the system, and the system generates a new work item based on that input.

[2204] "Task updating" refers to the process where a user inputs the content and progress of already created work items, and the system then modifies or adds information to the corresponding work items based on that input.

[2205] "Visualization of progress" means that the system displays the progress status of current work items in a format that allows for visual confirmation (e.g., Gantt chart or calendar format).

[2206] "Detection of progress delays" means that the system automatically determines whether a work item is behind schedule.

[2207] "Notification" refers to the system informing users of progress delays or important information via methods such as email or push notifications.

[2208] "Operator status information" refers to information that the worker inputs into the system, such as their work environment, work content, actions, and voice.

[2209] "Emotion recognition" refers to a system analyzing and determining an operator's emotional state based on their voice, actions, and other factors.

[2210] "Notifications and suggestions" refer to the system providing necessary warnings and action suggestions to the operator based on the results of emotion recognition.

[2211] A "generative AI model" refers to artificial intelligence that uses algorithms and networks trained through machine learning to analyze and generate emotional states and other information based on input data.

[2212] An "operator" is a user who uses a system to perform tasks.

[2213] "Team-wide emotional trends" refers to the trend in the overall emotional state of the team, obtained by analyzing emotional data collected from multiple operators.

[2214] The present invention is a task management system that integrates emotion recognition and performs comprehensive task management that takes into account the emotional state of the operator. This system includes means for creating and updating tasks, means for visualizing the progress of tasks, means for detecting and notifying of the risk of progress delays, means for performing emotion recognition based on the operator's status information, and means for making notifications and suggestions based on the results of emotion recognition.

[2215] Hardware and software to be used

[2216] The system configuration includes the following hardware and software:

[2217] Hardware: Industrial robots (e.g., robotic arms), smart displays, audio input devices, microphones.

[2218] Software: Python programs, EmotionEngine module, emotion recognition module, task management server API.

[2219] Overview of program processing

[2220] Task creation and update

[2221] The user inputs new work details into the robot within the factory, converts the information into JSON format, and sends it to the task management server. The server stores the task information in a database and generates new tasks. The progress of the created tasks is updated when the user inputs the information through the robot and sends it to the server.

[2222] Task visualization

[2223] Users can check the progress of tasks in real time via devices such as smart displays. All task information is received from the server in JSON format and visually displayed in Gantt charts and calendar formats.

[2224] Risk notification

[2225] The server periodically retrieves task progress information from the database and determines the risk of delays. The determined risk is communicated to the user through various means, including email and push notifications.

[2226] emotion recognition

[2227] An emotion recognition module is used to recognize the emotional state of the operator from their voice and actions while they perform their tasks. The EmotionEngine module analyzes the voice data collected by the robot and evaluates stress levels and satisfaction levels.

[2228] Emotion-based notifications and suggestions

[2229] Based on the assessed emotional state, the system provides the operator with appropriate notifications and suggestions. If the emotional recognition results indicate a high stress level, for example, a suggestion such as "Please take a break" will be sent via the robot.

[2230] Displaying sentiment data

[2231] Emotional data is analyzed on the server, and a function is provided to display the emotional trends of the entire team. This allows administrators to understand the team's emotional state and take appropriate measures.

[2232] Specific example

[2233] 1. Specific examples of creating and updating tasks:

[2234] An operator voice-inputs the task "factory machine maintenance" into the robot and sets the deadline as November 30, 2023. This information is converted to JSON format and sent to the server to generate a new task. When the task progress reaches 50%, the operator inputs the progress into the robot, and the updated information is sent to the server.

[2235] 2. Specific examples of emotion recognition and notification:

[2236] If an operator says "I'm tired" during work, the robot collects the audio, and an emotion recognition module evaluates the stress level. If the evaluation is high, the robot notifies the operator to "take a break."

[2237] 3. Specific examples of emotional data analysis:

[2238] The server analyzes emotional data collected from multiple operators and displays a result to the administrator indicating that "the team's stress level is high." The administrator then takes action based on this result.

[2239] Examples of prompts to input into a generative AI model:

[2240] "Please create a notification message for when a task is behind schedule."

[2241] "Generate suggestions for operators based on emotion recognition."

[2242] "Please generate a report showing the overall sentiment trends of the team."

[2243] This system integrates task progress management with worker emotional management, thereby improving work efficiency and overall satisfaction within the factory.

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

[2245] Step 1: Create a task

[2246] The user provides voice input to the robot specifying the details of a new task and its deadline. The robot converts this information into text and formats it into JSON format. For example, the input data might be "Task Name: 'Factory Machine Maintenance', Deadline: '2023-11-30'". The JSON data is sent to the server, which stores this data in its database and generates a new task.

[2247] Step 2: Update the task

[2248] The user inputs the work progress into the robot via voice. The robot converts this progress information into text and then formats it back into JSON format. The input data is, for example, "Task ID: '123', Progress: '50%'". The data converted to JSON format is sent to the server, which updates the database with information about the corresponding task.

[2249] Step 3: Visualize the task

[2250] The user sends a request from their device to the server to check the progress of their tasks. The server retrieves information on all tasks from the database and sends it back to the device in JSON format. The device parses the received data and displays it in a Gantt chart or calendar format.

[2251] Step 4: Detecting progress delays

[2252] The server periodically retrieves task progress information from the database and determines if there are any delays compared to the deadline. For comparison, data such as "Task ID: '123', Current Progress: '50%', Deadline: '2023-11-30'" is used. Tasks that are behind schedule are identified, and the server notifies the user of the delay risk.

[2253] Step 5: Emotion Recognition

[2254] An operator provides voice input to the robot while performing a task. The robot collects this voice data and sends it to an emotion recognition module. The emotion recognition module analyzes the voice data and determines the emotional state. An example of the input data is "audio data: 'audio_sample.wav'". The determined emotional state is output as a numerical value, such as a stress level.

[2255] Step 6: Emotion-based notifications and suggestions

[2256] Based on the emotional state data received from the emotion recognition module, the server generates necessary notifications and suggestions for the operator. If the emotional data indicates a "high stress level," the server notifies the operator to "take a break." Specific notification content, such as "recommendation to take a break," is generated, and the robot communicates this information to the operator via voice.

[2257] Step 7: Displaying emotion data

[2258] The server analyzes emotional data collected from multiple operators to visualize the emotional trends of the entire team. The analyzed data is sent to terminals and displayed on smart displays, etc. For example, the displayed content might be "Team-wide stress level: 'High'". This allows administrators to understand the emotional state of the entire team.

[2259] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the controlled object 443 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

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

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

[2262] Furthermore, the emotion identification model 59, acting as an emotion engine, may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to a specific mapping, which is an emotion map (see Figure 9). Similarly, the emotion identification model 59 may also determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[2263] Figure 9 shows an emotion map 400 in which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. The closer to the center of the concentric circles, the more primitive the emotions are located. Further out of the concentric circles, emotions representing states and actions arising from mental states are located. Emotion is a concept that includes feelings and mental states. On the left side of the concentric circles, emotions that are generally generated from reactions occurring in the brain are located. On the right side of the concentric circles, emotions that are generally induced by situational judgment are located. Above and below the concentric circles, emotions that are generally generated from reactions occurring in the brain and induced by situational judgment are located. In addition, the emotion of "pleasure" is located on the upper side of the concentric circles, and the emotion of "displeasure" is located on the lower side. Thus, in the emotion map 400, multiple emotions are mapped based on the structure in which emotions arise, and emotions that are likely to occur simultaneously are mapped close together.

[2264] These emotions are distributed at the 3 o'clock position on the Emotion Map 400, and usually fluctuate between feelings of security and anxiety. In the right half of the Emotion Map 400, situational awareness takes precedence over internal feelings, resulting in a calm impression.

[2265] The inside of the Emotion Map 400 represents inner thoughts, while the outside represents actions. Therefore, the further you go from the outside of the Emotion Map 400, the more visible (expressed in actions) your emotions become.

[2266] Here, human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. Similarly, in robots, cars, motorcycles, etc., emotions can be created based on various balances, such as posture and battery level. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. The emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on a system for analyzing brain physiological signals of speech emotion recognition and emotion, Tokushima University, doctoral dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map contains emotions belonging to a region called "response," where sensation is dominant. The right half of the emotion map contains emotions belonging to a region called "situation," where situational awareness is dominant.

[2267] The emotion map defines two emotions that promote learning. One is the emotion around the middle of the negative "repentance" and "reflection" on the situation side. In o...

Claims

1. Means for creating and updating tasks, A means of visualizing the progress of a task, A means to detect and notify about delays in task progress, A system that includes this.

2. The system according to claim 1, comprising means for monitoring the progress of a task in real time and determining the risk based on a comparison with the time remaining until the deadline.

3. The system according to claim 1, comprising means for providing notifications via email or push notifications.

Images