System

Abstract

To provide a system.SOLUTION: The system includes: means for receiving a task from a communication tool; means for acquiring task data on a task recorded in the past; determining the priority of the received task on the basis of the received task data; means for generating a task list organized according to the priority; and means for presenting the task list to the user.SELECTED DRAWING: Figure 1

Description

[Technical field]

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

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

[0003] [Patent Document 1] JP 2022-180282 A Summary of the Invention [Problem to be solved by the invention]

[0004] In modern work, many tasks are generated through communication tools, and it is necessary to properly manage and prioritize them. However, as the number of tasks increases, it takes a lot of time to organize them and determine their priorities, which can lead to a decrease in work efficiency. [Means for solving the problem]

[0005] The present invention receives tasks such as document review requests and meeting preparations from communication tools, determines the priority of the tasks from past records, and organizes the tasks based on the priority. Furthermore, if an urgent insertion task is received, the tasks are organized again and the organized tasks are presented to the user. Also, the progress of the user's tasks is recorded, improving the efficiency of task management. [Brief description of the drawings]

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

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

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

[0009] In the following embodiments, a signed processor (hereinafter simply referred to as a "processor") may be one arithmetic device or a combination of multiple arithmetic devices. Furthermore, a processor may be one type of arithmetic device or a combination of multiple types of arithmetic devices. Examples of arithmetic devices include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), an APU (Accelerated Processing Unit), or a TPU (TENSOR PROCESSING UNIT (registered trademark)).

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

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

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

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

[0014] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0027] "Example 1"

[0028] The embodiment of the present invention is a system that cooperates with a communication tool using an API, Webhook, etc., as a means for receiving tasks such as a request to review materials from the communication tool or preparation for a meeting. As a means for determining the priority of a task from past records, the priority is automatically determined using a machine learning algorithm based on information such as the completion time of the past task, the type of task, and the source of the task. As a means for organizing tasks based on priority, tasks are listed in descending order of priority and presented to the user. When an urgent insertion task is received, the tasks are organized again, and the organized tasks are presented to the user. In addition, as a means for recording the execution status of a user's task, the start time, end time, interruption time, etc. of the task are recorded, and the information is reflected in the next priority determination.

[0029] "Example 2"

[0030] As a specific example, consider a system that uses Slack as a communication tool and receives messages from Slack via an API. Based on the task content contained in the message, the time the message was sent, the sender, and other information, the system refers to the completion status of similar tasks in the past and determines the priority of a new task. Tasks are listed in order of highest priority and presented to the user. If an urgent insert task is received, the priority is determined again, including this task, and the task list is updated. When a user starts a task, the time is recorded, and when the task is completed, the time is recorded. This information is reflected in the next priority determination.

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

[0032] "Example 1"

[0033] Step 1: Receive tasks such as document review requests and meeting preparations from communication tools using APIs, Webhooks, etc.

[0034] Step 2: Based on the content of the received task, the time it was sent, the sender, and other information, the completion status of similar tasks in the past is referenced and the priority of the new task is determined.

[0035] Step 3: Present a list of tasks to the user, starting with the highest priority.

[0036] Step 4: If an urgent merge task comes in, reprioritize and update the task list to include that task.

[0037] Step 5: When a user starts a task, record the time, and when the task is completed, record the time. Use this information to inform the next priority decision.

[0038] "Example 2"

[0039] Step 1: Use Slack as a communication tool and receive messages from Slack via the API.

[0040] Step 2: Based on the task content contained in the message, the time the message was sent, the sender, and other information, the completion status of similar tasks in the past is referenced and the priority of the new task is determined.

[0041] Step 3: Present a list of tasks to the user, starting with the highest priority.

[0042] Step 4: If an urgent merge task comes in, reprioritize and update the task list to include that task.

[0043] Step 5: When a user starts a task, record the time, and when the task is completed, record the time. Use this information to inform the next priority decision.

[0044] Example 1

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

[0046] Conventional task management systems have difficulty efficiently receiving tasks from communication tools, properly determining priorities, and presenting them to users. They also lacked the functionality to reorganize tasks when an urgent insertion task occurs, or the functionality to record the user's task completion status and reflect it in the next priority determination. This made task management cumbersome for users and hindered efficient task completion.

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

[0048] In this invention, the server includes a means for receiving tasks from a communication tool, a means for analyzing the contents of the received tasks, a means for collecting past task data, a means for determining task priorities using a machine learning algorithm, a means for organizing tasks based on priorities, a means for reorganizing tasks when an urgent insertion task is received, a means for presenting the organized task list to the user, a means for recording the user's task performance status, and a means for reflecting the recorded performance status in the next priority determination. This makes it possible to consistently perform tasks from receiving them to determining priorities, organizing them, presenting them, and recording their performance status, thereby making the user's task management more efficient.

[0049] A "communication tool" is software or a platform that enables a user to exchange information with other users. Examples include messaging applications and video conferencing systems.

[0050] A "task" is a specific task or activity that a user needs to accomplish. Examples include requesting a document for review or preparing for a meeting.

[0051] A "server" is a computer system that processes data and provides services to other devices over a network.

[0052] "API" stands for Application Program Interface, a set of rules and tools for exchanging data and functions between different software programs.

[0053] A "Webhook" is a mechanism that sends an HTTP request to a specified URL when a specific event occurs.

[0054] A "machine learning algorithm" is a computational method for learning patterns from data and making predictions or classifications. Examples include random forests and support vector machines.

[0055] "Priority" is an indicator of the importance or urgency of a task. A task with a high priority should be completed before other tasks.

[0056] A "task list" is a list of tasks that a user needs to complete, organized according to priority.

[0057] "Performance status" is information that describes how a user is progressing through a task. Examples include the start time, end time, and interruption time of the task.

[0058] A "database" is a system for efficiently storing, searching, and managing data.

[0059] The present invention is a system for efficiently receiving tasks from a communication tool, appropriately determining priorities, and presenting them to a user. A specific embodiment of this system will be described below.

[0060] The server receives tasks from communication tools (e.g. messaging applications and video conferencing systems) using APIs or Webhooks. For example, you can set up a Slack Webhook to get task information when a new message is posted.

[0061] The server analyzes the received task contents using natural language processing (NLP) technology. For example, it extracts keywords such as "review request" or "meeting preparation" from the task title and description.

[0062] The server then collects historical task data from the database, for example using a SQL query to get the completion time and origin of review tasks for the past year.

[0063] The collected past task data is input into a machine learning algorithm (e.g., random forest or support vector machine) to predict the priority of new tasks. For example, the past data is input as features into the model, and a priority score is output.

[0064] The server sorts the tasks based on the priority score and lists them in descending order of priority, i.e., placing tasks with a higher priority score at the top of the list.

[0065] The organized task list is sent from the server to the terminal and presented to the user. The terminal displays the task list to the user and encourages the user to tackle the tasks in order of priority.

[0066] If an urgent injecting task occurs, the server re-organizes the tasks, e.g., when a new urgent task is added, it recalculates the existing task list and sends the updated list to the terminal.

[0067] The time when a user starts, finishes, or stops a task is recorded by the device. For example, when a user presses the "start button" to start a task, the start time is recorded.

[0068] The recorded performance data is sent to the server and reflected in the next priority decision. For example, the task completion time and interruption time are used as training data for the next machine learning model.

[0069] Examples

[0070] Example 1: Requesting a document review

[0071] A user receives a message on Slack saying, "Please review the document." The server receives this message and determines the priority based on the data of past review tasks. If the priority is high, the server notifies the device, "Please give priority to reviewing the document."

[0072] Example 2: Preparing for a meeting

[0073] A user receives a task on MICROSOFT(R) TEAMS(R) saying "Please prepare for tomorrow's meeting." The server receives this task and determines the priority based on the data of past meeting preparation tasks. If the priority is low, the server notifies the terminal "Please postpone preparation for the meeting."

[0074] Examples of prompt statements

[0075] "Please prioritize review requests for materials received via Slack. Determine the priority based on the completion time of past review tasks, the type of task, and the source of the task. If the request is high priority, notify the user."

[0076] In this way, we have specifically explained how the server, terminal, and user work together to determine and organize task priorities and present them to the user.

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

[0078] Step 1:

[0079] The server receives tasks from the communication tool using an API or Webhook.

[0080] Input: Task information from communication tools (e.g. Slack messages)

[0081] Output: Received task information

[0082] Specific operation: The server sets up a Slack webhook and receives the contents of a new message when it is posted. For example, it receives a message saying "Please review the document."

[0083] Step 2:

[0084] The server analyzes the contents of the received task.

[0085] Input: Received task information

[0086] Output: Information about the parsed tasks, such as type, origin, and deadline

[0087] Specific operation: The server uses natural language processing (NLP) technology to extract keywords such as "review request" and "meeting preparation" from the task title and description. For example, the server extracts the keyword "review request" from the message "Please review the materials."

[0088] Step 3:

[0089] The server collects past task data from a database.

[0090] Input: Information about the parsed task, such as type, origin, and due date

[0091] Output: Historical task data (e.g. completion time, task type, origin)

[0092] Specific operation: The server uses an SQL query to retrieve the completion time and origin of review tasks from the database over the past year. For example, it collects past task data related to "review requests."

[0093] Step 4:

[0094] The server uses machine learning algorithms to prioritize new tasks based on the past task data it has collected.

[0095] Input: Past task data

[0096] Output: The priority score of the new task.

[0097] Specific operation: The server uses machine learning algorithms such as random forests and support vector machines to input past data as features into a model and output a priority score. For example, it calculates the priority score for a "review request."

[0098] Step 5:

[0099] The server organizes the tasks based on the priority score, listing them in order of priority.

[0100] Input: The priority score of the new task

[0101] Output: An organized task list

[0102] Specific behavior: The server will place tasks with higher priority scores at the top of the list. For example, if "review request" has a high priority score, it will be placed at the top of the list.

[0103] Step 6:

[0104] The server transmits the organized task list to the terminal and presents it to the user.

[0105] Input: An organized task list

[0106] Output: The task list presented to the user.

[0107] Specific operation: The server sends the organized task list to the terminal, and the terminal displays the task list to the user. For example, the user's screen displays "request review" as the top priority task.

[0108] Step 7:

[0109] The server re-arranges tasks if an urgent merge task occurs.

[0110] Input: Urgent mail merge task information

[0111] Output: Updated task list.

[0112] Specific operation: The server recalculates the existing task list when a new urgent task is added and sends the updated list to the terminal. For example, if "urgent meeting preparation" is added, the task list is reorganized.

[0113] Step 8:

[0114] The device records the time when a user starts, finishes, and stops a task.

[0115] Input: User task performance (start time, end time, interruption time)

[0116] Output: Logged performance data

[0117] Specific operation: When a user starts a task, the device records the start time by pressing the "Start" button. Similarly, when the user finishes the task, the device records the end time by pressing the "End" button.

[0118] Step 9:

[0119] The server reflects the recorded performance data in the next priority determination.

[0120] Input: Recorded performance data

[0121] Output: An updated machine learning model.

[0122] Specific operation: The server stores the progress data received from the terminal in a database and uses it as training data for the next machine learning model, for example, to reflect the task completion time and interruption time in the next priority determination.

[0123] (Application example 1)

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

[0125] Conventional factory robots required manual task prioritization, making efficient task management difficult. In addition, when an urgent intervening task occurred, it was difficult to quickly reset task priorities, which could result in work delays and reduced efficiency. Furthermore, there was an insufficient means of recording the task execution status, making it impossible to reflect this in the next task priority determination.

[0126] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means. In this invention, the server includes a means for receiving tasks such as a request for reviewing materials from a communication tool and preparation for a meeting, a means for determining the priority of tasks from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for receiving tasks from a management system or a communication tool in a factory, a means for determining the priority of tasks using a machine learning algorithm based on past task data, a means for listing tasks in order of priority and presenting them to a robot, and a means for recording the start time, end time, interruption time, etc. of a task and reflecting them in the next priority determination. This enables the factory robot to efficiently manage tasks and quickly respond to urgent tasks, thereby preventing work delays and efficiency declines.

[0127] A "communication tool" is software or an application that allows users to exchange information between each other.

[0128] A "material review request" is a request to review and provide feedback on specific documents or data.

[0129] "Preparing for a meeting" refers to the task of gathering the materials and information necessary to ensure the meeting proceeds smoothly.

[0130] A "task" is an operation or activity that must be performed to achieve a particular purpose.

[0131] "Past records" are data about previously performed tasks and their results.

[0132] "Priority" is an indicator of the importance and urgency of a task.

[0133] A "machine learning algorithm" is a computational technique for learning patterns from data and making predictions or classifications.

[0134] "Factory management systems" is a general term for software and hardware used to manage factory operations and production activities.

[0135] The "start time of a task" is the time when the task actually starts.

[0136] "Task end time" is the time when the task is completed.

[0137] A "task suspension time" is a period of time during which a task is temporarily stopped.

[0138] A "robot" is a mechanical device that performs specific tasks automatically.

[0139] "Task progress status" is information that indicates the state or progress of a task.

[0140] A system for carrying out the present invention includes an application installed on a robot used in a factory. A specific embodiment of this system will be described below.

[0141] System Configuration

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

[0143] 1. Communication tools: Software or applications that allow users to exchange information between each other.

[0144] 2. Factory management systems: Software and hardware for managing factory operations and production activities.

[0145] 3. Robot: A mechanical device used to perform specific tasks automatically.

[0146] 4. Server: A central processing unit for receiving tasks, determining priorities, organizing tasks, and recording their execution status.

[0147] Program Processing

[0148] The server processes the data in the following steps:

[0149] 1. Receiving a task:

[0150] The server receives tasks from the factory's management system and communication tools, and the tasks to be executed by the robots are then consolidated on the server.

[0151] 2. Prioritization:

[0152] The server uses a machine learning algorithm to determine task priorities based on past task data. Specifically, it uses information such as past task completion times, task types, and origins as input data and predicts priorities using a generative AI model.

[0153] 3. Organize your tasks:

[0154] The server lists tasks in order of priority and presents them to the robot, allowing the robot to complete the tasks efficiently.

[0155] 4. Recording task completion status:

[0156] The server records the start time, end time, interruption time, etc. of the task and reflects this in the next priority determination, thereby improving the accuracy of task management.

[0157] Hardware and Software Used

[0158] Hardware: Factory robots, servers

[0159] Software: Python, scikit-learn (machine learning library), requests (HTTP request library)

[0160] Examples

[0161] For example, if a robot in a factory receives an "assembly task" and an "inspection task," past data will determine that the "assembly task" has a higher priority. The robot will carry out the "assembly task" first, and then the "inspection task." In this way, the robot can efficiently manage tasks and quickly respond to emergency tasks.

[0162] Examples of prompt statements

[0163] Design a system that automatically prioritizes tasks received by robots in factories and allows them to complete tasks efficiently. Use a machine learning algorithm to determine priorities based on past task data, and give the system the ability to list tasks in order of priority and present them to the robots. Also, add a function to record the task completion status and reflect it in the next priority determination.

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

[0165] Step 1:

[0166] The server receives tasks from the management system and communication tools in the factory. Specifically, it obtains task data from the API using an HTTP request. The input includes detailed task information (task ID, task content, origin, etc.). The output is that the received task data is stored in the server.

[0167] Step 2:

[0168] The server uses a machine learning algorithm to determine task priorities based on past task data. Specifically, it uses information such as past task completion times, task types, and origins as input data and predicts priorities using a generative AI model. The inputs include past task data and new task data. The output is the priority of each task.

[0169] Step 3:

[0170] The server lists tasks in descending order of priority and presents them to the robot. Specifically, the server sorts the tasks in descending order of priority and sends them to the robot in list form. The input includes task data with the determined priorities. The output is the sorted task list presented to the robot.

[0171] Step 4:

[0172] The robot performs tasks based on the presented task list. Specifically, it executes the tasks from the top of the list and records the start and end times of the tasks. The input includes a sorted task list. The output records the execution results of the performed tasks and their timestamps.

[0173] Step 5:

[0174] The server records the task execution status and reflects it in the next priority decision. Specifically, the start time, end time, interruption time, etc. of the task are stored in a database and used as training data for the next machine learning model. The input includes the execution result and timestamp of the completed task. The output is an updated task database.

[0175] Example 2

[0176] Next, a second embodiment of the second embodiment will be described. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0177] In conventional task management systems, it was difficult to properly determine the priority of tasks received from communication means and to reorganize tasks when an urgent insertion task occurred. In addition, there was a lack of functionality to record the user's task execution status and reflect it in the next priority determination, making it impossible to achieve efficient task management.

[0178] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving a task from a communication means, a means for saving information on the received task, a means for determining the priority of the task from past records, a means for organizing the tasks based on the priority, a means for reorganizing the tasks when an urgent insertion task is received, a means for recording the start time and completion time of the user's task, and a means for reflecting the recorded information in the next priority determination. This makes it possible to appropriately determine the priority of the task, quickly respond to an emergency task, and efficiently manage tasks reflecting the user's performance status.

[0179] A "communication means" is a device or system for sending and receiving information via a network.

[0180] A "task" is an operation or activity that must be performed to achieve a particular goal.

[0181] A "receiving means" is a function or process for obtaining information sent from a communication means.

[0182] "Means of storage" refers to the functions or processes for recording received information in a database or storage.

[0183] "Past records" refers to previously saved task status and related information.

[0184] A "prioritization method" is a function or process for evaluating and ranking the importance and urgency of tasks.

[0185] "Organizing tools" are functions or processes that sort tasks based on determined priorities and make them more manageable.

[0186] An "urgent in-place task" is a task that arises unexpectedly and requires immediate attention.

[0187] A "means for re-ordering tasks" is a function or process for re-evaluating and re-ordering the priority of existing tasks when an urgent insert task arises.

[0188] "Start time" is the time when the user begins the task.

[0189] "Completion Time" is the time when a user completes a task.

[0190] A "means for recording" is a function or process for recording the start time and completion time of a task in a database or storage.

[0191] "Means for reflecting in next priority determination" refers to a function or process for more accurately evaluating the priority of the next task based on the recorded information.

[0192] A "generative AI model" is a model that uses artificial intelligence to analyze data and is trained to perform a specific task.

[0193] This invention relates to a task management system that can appropriately determine the priority of tasks received from communication means and can quickly respond to urgent tasks. Furthermore, it records the task execution status of users and reflects it in the next priority determination, thereby realizing efficient task management.

[0194] Hardware and Software Used

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

[0196] Software: communications tools (e.g. messaging applications), communications APIs, databases (e.g. MySQL®), generative AI models (e.g. GPT-4®)

[0197] System Overview

[0198] 1. Receiving a Message

[0199] The server receives the task sent from the communication means using the communication means API.

[0200] For example, the server may receive a task to "create a proposal for a new project."

[0201] 2. Data storage

[0202] The server stores the received task contents, sending time, and sender information in a database.

[0203] For example, the task content “Create a proposal for a new project”, the sending time “2023-10-01 10:00:00”, and the sender “user123” are saved.

[0204] 3. Reference to past data

[0205] The server refers to a database for past execution status of similar tasks.

[0206] For example, it is referenced that the completion time of the past "Write proposal" task was "2023-09-25 15:00:00".

[0207] 4. Determining Priorities

[0208] The server uses a generative AI model (e.g. GPT-4) to prioritize new tasks.

[0209] For example, an AI model may rate the task "Create a proposal for a new project" as a "high" priority.

[0210] 5. Creating a task list

[0211] The server creates a task list by listing tasks in descending order of priority.

[0212] For example, on your task list you might write "1. Create a proposal for new project" and "2. Prepare for client meeting."

[0213] 6. Dealing with Urgent Tasks

[0214] If an urgent insertion task is received, the server will re-determine the priority including that task.

[0215] For example, if an urgent task such as "responding to a sudden inquiry from a client" comes in, the task list is updated.

[0216] 7. Recording when tasks are started and completed

[0217] When a user starts a task, the time is recorded from the device.

[0218] For example, if a user starts a task "Create a proposal for a new project" at 10:30 and completes it at 12:00, record that time.

[0219] 8. Reflection in the next priority decision

[0220] The server will use the recorded task start and completion times to determine the next priority.

[0221] For example, it can learn that past "proposal writing" tasks took an average of two hours and reflect that in determining the next priority.

[0222] Examples of prompt statements

[0223] "Please explain a system that determines the priority of tasks and generates a task list based on messages received from a communication means. Please explain the specific process flow and the hardware and software used."

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

[0225] Step 1:

[0226] Receiving messages

[0227] The server receives the task sent from the communication means using the communication means API.

[0228] Input: Message data from the communication medium (e.g. task content, sending time, sender)

[0229] Output: Received message data

[0230] What happens: The server sets up a communication API and listens for messages from a specific channel or user, for example, to receive a message saying "Create a proposal for a new project."

[0231] Step 2:

[0232] Data storage

[0233] The server stores information about the received message, including the content, time of sending, and sender in a database.

[0234] Input: Received message data

[0235] Output: Task information stored in a database

[0236] Specific operation: The server executes an INSERT statement in a database such as MySQL to save the data. For example, it saves the task content "Create a proposal for a new project", the sending time "2023-10-01 10:00:00", and the sender "user123".

[0237] Step 3:

[0238] View past data

[0239] The server refers to a database for past execution status of similar tasks.

[0240] Input: Past task data in the database

[0241] Output: Referenced past task data

[0242] Specific operation: The server executes a SELECT statement to obtain the completion time and priority of past "Write proposal" tasks. For example, it references that the completion time of the past "Write proposal" task was "2023-09-25 15:00:00".

[0243] Step 4:

[0244] Determining Priorities

[0245] The server uses a generative AI model (e.g. GPT-4) to prioritize new tasks.

[0246] Input: Referenced previous task data, new task data

[0247] Output: Determined task priority

[0248] How it works: The server inputs past data into the AI ​​model and evaluates the urgency and importance of the task. For example, the AI ​​model evaluates the task "Create a proposal for a new project" as a "high" priority.

[0249] Step 5:

[0250] Generate a task list

[0251] The server creates a task list by listing tasks in descending order of priority.

[0252] Input: Determined task priority

[0253] Output: task list

[0254] What it does: The server sorts the tasks based on priority and stores them in a database in list format. For example, a task list might read "1. Create a proposal for a new project" and "2. Prepare for a client meeting."

[0255] Step 6:

[0256] Dealing with Urgent Tasks

[0257] If an urgent insertion task is received, the server will re-determine the priority including that task.

[0258] Input: New urgent task data, existing task list

[0259] Output: Updated task list

[0260] Specific operation: The server inputs new tasks into the AI ​​model and reevaluates the overall priority. For example, if an urgent task such as "responding to an urgent inquiry from a client" is received, the task list is updated.

[0261] Step 7:

[0262] Recording task initiation and completion

[0263] When a user starts a task, the time is recorded from the device.

[0264] Input: Task start time, completion time

[0265] Output: Recorded task start and completion times

[0266] Specific operation: The user presses the "Start" button through the terminal interface, and the server saves the time in the database. When the task is completed, the user presses the "Finish" button in the same way, and the completion time is recorded. For example, if the user starts the task "Write a proposal for a new project" at 10:30 and completes it at 12:00, the time will be recorded.

[0267] Step 8:

[0268] Reflection in next priority decision

[0269] The server will use the recorded task start and completion times to determine the next priority.

[0270] Input: Recorded task start and completion times

[0271] Output: Data reflected in the next priority decision

[0272] How it works: The server inputs past execution times and completion status into the AI ​​model to more accurately evaluate the next task priority. For example, it learns that past "proposal writing" tasks took an average of two hours, and reflects this in determining the next priority.

[0273] (Application example 2)

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

[0275] In conventional task management systems, it was difficult to properly determine the priorities of complex tasks in a factory and to manage them efficiently. In addition, when an urgent task occurred, it was not possible to quickly update the task list and reset the appropriate priority. Furthermore, there was a lack of a mechanism to record the task execution status and reflect it in the next priority determination, which led to a problem of reduced overall work efficiency.

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

[0277] In this invention, the server includes a means for receiving tasks such as a request for reviewing materials from a communication tool or preparation for a meeting, a means for determining the priority of tasks from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for receiving task information from a management system in a factory, a means for analyzing information such as the content of a task, the sending time, and the sender, a means for recording the task start time and completion time, a means for determining the priority of a task using a generative AI model, and a means for generating a prompt sentence. This makes it possible to appropriately determine the priority of complex tasks in a factory and efficiently manage them. Furthermore, even if an urgent insertion task occurs, the task list can be quickly updated and the priority can be reset appropriately. In addition, by recording the progress of the tasks and reflecting it in the next priority determination, the overall work efficiency can be improved.

[0278] A "communication tool" is software or a platform that allows users to exchange messages or information between each other.

[0279] A "material review request" is a request to review specific documents or data and seek feedback or corrections.

[0280] "Preparing for a meeting" refers to the task of collecting and organizing the materials and information necessary to ensure the smooth running of the meeting.

[0281] A "task" is a unit of work or activity that must be performed to achieve a specific purpose.

[0282] "Past records" are data showing the progress and results of tasks previously performed.

[0283] "Priority" is an index of importance that indicates which of multiple tasks should be performed first.

[0284] "Organizing" is the act of classifying and arranging tasks based on certain criteria.

[0285] An "urgent inject task" is a task or activity that arises unexpectedly and requires immediate attention.

[0286] "Factory management systems" is a general term for software and hardware used to oversee and manage a factory's production activities and operations.

[0287] "Task information" is detailed data such as the task content, sending time, sender, and so on.

[0288] "Analysis" is the process of examining data or information in detail to clarify its meaning and structure.

[0289] "Task start time" is the time when a particular task actually begins.

[0290] "Task completion time" is the time when a particular task is actually completed.

[0291] A "generative AI model" is an algorithm or program that uses artificial intelligence technology to analyze data and generate new information or results.

[0292] A "prompt" is an instruction or question to be input into a generative AI model.

[0293] A system for carrying out the present invention is for linking with a management system within a factory, appropriately determining task priorities, and efficiently managing the tasks. A specific embodiment of the system will be described below.

[0294] System Configuration

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

[0296] 1. Server: Plays a central role in receiving task information, analyzing it, and determining priorities.

[0297] 2. Factory management system: A system that provides task information, such as an MES system.

[0298] 3. Generative AI Model: An artificial intelligence model used to prioritize tasks.

[0299] 4. User terminal: A device that displays the task list and allows the user to manage the progress of tasks.

[0300] Program Processing

[0301] The server receives task information from the factory's management system. The task information includes detailed data such as the task content, transmission time, and sender. The server analyzes this information and determines the priority of the task based on past records. A generative AI model is used to determine the priority.

[0302] The server organizes tasks based on priority and presents a task list to the user terminal. If an urgent insertion task occurs, the server determines the priority again and updates the task list. It records the time when the user starts and completes the task, and reflects this in the next priority determination.

[0303] Hardware and Software Used

[0304] Hardware: Factory robots (e.g. KUKA, Fanuc, etc.), user terminals (e.g. PCs, tablets)

[0305] Software: Python, API communication library (requests), generative AI model

[0306] Examples

[0307] For example, when a new task is sent from the management system in a factory, the server receives the task, determines its priority, and updates the task list. If an urgent maintenance task is received, the server gives priority to the task.

[0308] Examples of prompt statements

[0309] An example of a prompt to be input to the generative AI model is as follows:

[0310] A new task has been sent from the factory management system. The task content is "Maintenance of Machine A", the sending time is "2023-10-01T10:00:00", and the sender is "Administrator". Please determine the priority of this task and update the task list.

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

[0312] Step 1:

[0313] The server receives task information from the management system in the factory. The input is the task information sent from the management system, and the output is the received task information data. In concrete terms, the server obtains the task information through the API and stores details such as the task content, sending time, and sender in the database.

[0314] Step 2:

[0315] The server analyzes the received task information. The input is the task information received in step 1, and the output is the analyzed task details. In concrete terms, the server extracts information such as the task content, sending time, sender, etc., and stores these data in individual variables.

[0316] Step 3:

[0317] The server determines the priority of a task based on past records. The input is the analyzed task details and past task records, and the output is the determined task priority. In concrete terms, the server uses a generative AI model to refer to past task execution status and calculate the priority of the current task.

[0318] Step 4:

[0319] The server organizes tasks based on priority. The input is the determined task priority, and the output is the organized task list. In concrete terms, the server generates a task list according to the task priority and sorts the tasks by priority.

[0320] Step 5:

[0321] The server presents the organized task list to the user terminal. The input is the organized task list, and the output is the task list displayed on the user terminal. In specific operation, the server transmits the task list to the user terminal for the user to view.

[0322] Step 6:

[0323] When an urgent insertion task occurs, the server re-determines the priority and updates the task list. The input is the urgent insertion task information, and the output is the updated task list. In concrete terms, the server analyzes the newly received urgent task, re-determines the priority using the generative AI model, and updates the task list.

[0324] Step 7:

[0325] The user records the time when the task is started and completed. The input is the task information that the user reports as started and completed, and the output is the recorded task start and completion times. In concrete terms, the user presses a button when the task is started, and also presses a button when the task is completed, and the start and completion times are sent to the server.

[0326] Step 8:

[0327] The server reflects the recorded task performance status in the next priority determination. The input is the recorded task start time and completion time, and the output is the data to be used in the next priority determination. In concrete terms, the server stores the task performance time in a database and refers to this data when determining the next task priority.

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

[0329] "Example 1"

[0330] One embodiment of the present invention is a task management system incorporating an emotion engine. This system recognizes the emotions of a user and adjusts task priorities based on the user's emotional state. Specifically, if the emotion engine recognizes that the user is feeling stressed, it increases the priority of tasks that have the potential to reduce the stress. In addition, if the emotion engine recognizes that the user is relaxed, it increases the priority of tasks that require concentration. This allows the user to perform optimal tasks according to their emotional state.

[0331] "Example 2"

[0332] In another embodiment of the present invention, there is a system in which an emotion engine adjusts the way in which tasks are presented based on the emotional state of the user. Specifically, if the emotion engine recognizes that the user is feeling impatient, it presents tasks one by one, thereby reducing the burden on the user. On the other hand, if the emotion engine recognizes that the user is calm, it presents multiple tasks simultaneously, thereby improving the user's productivity. This makes it possible to present optimal tasks according to the user's emotional state.

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

[0334] "Example 1"

[0335] Step 1: The emotion engine recognizes the user's emotional state.

[0336] Step 2: Adjust the priority of tasks based on the emotional state recognized by the emotion engine. For example, if it recognizes that the user is feeling stressed, it will increase the priority of tasks that may reduce stress.

[0337] Step 3: Present tasks to users based on the adjusted priorities.

[0338] "Example 2"

[0339] Step 1: The emotion engine recognizes the user's emotional state.

[0340] Step 2: Based on the emotional state recognized by the emotion engine, adjust the way tasks are presented. For example, if it recognizes that the user is feeling impatient, present the tasks one by one. Step 3: Based on the adjusted presentation method, present the tasks to the user.

[0341] Example 1

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

[0343] Conventional task management systems cannot take into account the user's emotional state when determining task priorities, making it difficult to optimally manage tasks according to the user's stress and concentration. In addition, there are problems such as not being able to quickly reorganize tasks when an urgent insert task occurs, and lacking a function to record the user's task execution status and reflect it in the next priority determination.

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

[0345] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool or preparations for a meeting, a means for determining task priority from past records, a means for organizing tasks based on priority, a means for reorganizing tasks when an urgent insertion task is received, a means for recognizing the emotional state of a user and adjusting task priority based on the emotional state, a means for recording the start time, end time, interruption time, etc. of a user's task, and a means for presenting the organized tasks to the user. This enables optimal task management according to the emotional state of the user, and realizes rapid reorganization of urgent tasks, recording of task execution status, and reflection of the status in the next priority determination.

[0346] "Communication Tools" means software or platforms that Users use to exchange information with other Users.

[0347] A "task" refers to a specific task or activity that a user needs to accomplish.

[0348] "Priority" is an index of importance that indicates which task among multiple tasks should be performed first.

[0349] "Emotional state" refers to the user's psychological state and includes emotions such as stress or relaxation.

[0350] An "emotion engine" is an algorithm or software for recognizing a user's emotional state and adjusting the system's behavior based on that state.

[0351] "Task completion status" refers to information such as the time when a user started a task, the time when the user finished the task, and the time when the user stopped the task.

[0352] An "urgent inject task" is a high-priority task that is unexpectedly added to an existing task list.

[0353] A "database" is a system for storing information such as past task data and user performance status.

[0354] A "machine learning algorithm" is an algorithm that learns patterns based on past data and makes predictions and classifications for new data.

[0355] An "API" is an interface that allows different software systems to communicate with each other.

[0356] A "Webhook" is a mechanism that sends an HTTP request to a specified URL when a specific event occurs.

[0357] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0358] This invention is a system that receives tasks from a communication tool, determines the priority of the tasks based on past records and the emotional state of the user, and presents the organized tasks to the user. A specific embodiment of this system will be described below.

[0359] Receiving tasks from communication tools

[0360] The server receives tasks from communication tools (e.g. Slack, Microsoft Teams) using APIs or Webhooks. For example, by setting up a Slack Webhook, when a new message is posted in a specific channel, the server receives the message.

[0361] Parsing task information

[0362] The server parses the received message and extracts details such as task type, origin, deadline, etc. For example, when a message is posted saying "Please prepare for a meeting," the server extracts the task type "prepare for a meeting" and the origin "Slack."

[0363] Get past task data

[0364] The server retrieves information from the database about past task completion times, task types, origins, etc. For example, it checks how long similar tasks took to complete in the past.

[0365] Task Prioritization

[0366] The server uses machine learning algorithms (e.g., random forests, support vector machines) to prioritize new tasks based on past task data. For example, tasks that took a long time in the past are set to a higher priority.

[0367] Organizing and listing tasks

[0368] The server will organize the tasks based on priority and list them in order of priority, for example the "prepare for meeting" task will be at the top of the list as it has the highest priority.

[0369] Present tasks to users

[0370] The terminal presents the user with an organized task list. For example, the user's PC screen shows "Prepare for a meeting" as the top priority task.

[0371] Handling urgent tasks

[0372] If an urgent merge task occurs, the server reorganizes the tasks and sends the updated list to the terminal. For example, if an "urgent bug fix" occurs, that task is displayed at the top of the list as the highest priority.

[0373] Recording task completion status

[0374] The server records the start time, end time, interruption time, etc. of a user's task. For example, the server records the time when a "prepare for meeting" task was started and ended.

[0375] Prioritization using emotion engine

[0376] The server uses an emotion engine to recognize the user's emotional state and adjusts task priorities based on that state. For example, if the user is feeling stressed, it will increase the priority of the "reading materials" task, which is relaxing.

[0377] Examples of concrete examples and prompts

[0378] Examples

[0379] When a user uses Slack, a "prepare for a meeting" task is sent to the server via Slack's webhook. The server determines the priority based on the data of past meeting preparation tasks and lists them as high-priority tasks. If the emotion engine recognizes that the user is feeling stressed, it sets the "reading materials" task, which is relaxing, as a high priority.

[0380] Examples of prompt statements

[0381] "Try to prioritize meeting preparation tasks you receive from Slack, and if users are feeling stressed, prioritize tasks that will help them relax."

[0382] In this way, by explaining the system processing from the perspectives of the server, terminal, and user, the specific operations and technologies used become clear.

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

[0384] Step 1:

[0385] The server receives tasks from the communication tool using an API or Webhook.

[0386] Input: Task information from communication tools (e.g. Slack messages)

[0387] Output: Received task information

[0388] Specific operation: The server sets up a Slack webhook and receives the contents of a new message posted in a specific channel. For example, when a message "Please prepare for a meeting" is posted, the contents are sent to the server.

[0389] Step 2:

[0390] The server parses the received task information and extracts details such as the task type, origin, and deadline.

[0391] Input: Received task information

[0392] Output: Detailed information about the parsed tasks (task type, origin, deadline, etc.)

[0393] Specific operation: The server analyzes the received message, extracts the task type "prepare for meeting" and the source "Slack", and identifies the deadline from the date information included in the message.

[0394] Step 3:

[0395] The server retrieves information such as past task completion times, task types, and origins from the database.

[0396] Input: Task details

[0397] Output: Past task data

[0398] What happens: The server queries the database to get past completion times for "prepare for meeting" tasks and tasks originating from "Slack." For example, it checks how long similar tasks took to complete in the past.

[0399] Step 4:

[0400] The server uses machine learning algorithms to determine the priority of new tasks based on the past task data it has acquired.

[0401] Input: Past task data, detailed task information

[0402] Output: Determined task priority

[0403] How it works: The server uses a random forest algorithm to analyze past task data and determine the priority of new tasks. For example, tasks that took a long time in the past are set to a higher priority.

[0404] Step 5:

[0405] The server organizes tasks based on priority, listing them in descending order of priority.

[0406] Input: Determined task priority

[0407] Output: An organized task list

[0408] What happens: The server sorts the tasks based on priority and lists them in order of priority. For example, the "Prepare for meeting" task is the top priority and appears at the top of the list.

[0409] Step 6:

[0410] The terminal presents the user with an organized task list.

[0411] Input: An organized task list

[0412] Output: The task list presented to the user.

[0413] Specific operation: The terminal displays an organized task list on the user's PC screen. For example, "Prepare for meeting" is displayed as the top priority task.

[0414] Step 7:

[0415] If an urgent insertion task occurs, the server reorganizes the tasks and transmits an updated list to the terminal.

[0416] Input: Urgent mail merge task information

[0417] Output: Updated task list.

[0418] What it does: If an urgent merge task occurs, the server adds it to the list and sorts the tasks again based on priority. For example, if an "urgent bug fix" occurs, that task will be displayed at the top of the list as the highest priority.

[0419] Step 8:

[0420] The server records the start time, end time, interruption time, etc. of a user's task.

[0421] Input: User's task performance status

[0422] Output: Recorded task performance data

[0423] Specific operation: The server records the time when the user starts, finishes, and stops a task. For example, it records the time when the "prepare for meeting" task starts and ends.

[0424] Step 9:

[0425] The server uses an emotion engine to recognize the user's emotional state and adjusts task priorities based on that state.

[0426] Input: The user's emotional state

[0427] Output: Adjusted task priorities

[0428] Specific operation: The server uses the emotion engine to analyze the user's emotional state, and if the user is feeling stressed, it increases the priority of tasks that will relax the user. For example, if the server recognizes that the user is feeling stressed, it increases the priority of the "reading materials" task.

[0429] (Application example 1)

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

[0431] In conventional task management systems, the user's emotional state or the robot's operating status could not be taken into account when determining task priorities, making it difficult to carry out tasks efficiently. In addition, when an urgent intervening task occurs, tasks are often not reorganized promptly, resulting in a decrease in work efficiency.

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

[0433] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool and preparations for a meeting, a means for determining task priority from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for determining task priority using a machine learning algorithm, a means for adjusting task priority based on the emotional state of a user using an emotion engine, and a means for recognizing the state of the robot based on data from the robot's sensor and adjusting task priority. This enables efficient task management that takes into account the emotional state of the user and the operating status of the robot.

[0434] A "communication tool" is software or a platform that allows users to exchange information.

[0435] A "request for document review" is a task to check the contents of a specific document or data and ask for opinions or corrections.

[0436] "Preparing for a meeting" is the task of preparing the materials and information necessary to ensure the meeting proceeds smoothly.

[0437] A "task" is an operation or activity that must be performed to achieve a particular purpose.

[0438] "Past records" are data about previously performed tasks and their results.

[0439] "Priority" is an indicator of the importance and urgency of a task.

[0440] A "machine learning algorithm" is a computational technique that learns patterns from data and makes predictions and classifications.

[0441] An "emotion engine" is a technology for recognizing a user's emotional state and adjusting the system's behavior based on that.

[0442] A "robot" is a mechanical device that performs tasks automatically.

[0443] A "sensor" is a device that detects information about the physical environment and outputs it as data.

[0444] "Adjusting task priorities" means reevaluating the importance and urgency of tasks and changing the order of execution.

[0445] "Task organization" means classifying and ordering tasks in order to manage them efficiently.

[0446] An "urgent inject task" is a task that occurs unscheduled and requires immediate attention.

[0447] The system for carrying out the present invention is configured as follows: The server has a means for receiving tasks such as requests to review materials and preparations for meetings from communication tools, allowing the user to obtain tasks directly from the communication tool he or she is using.

[0448] Next, the server has a means to determine the priority of tasks from past records. Priorities are automatically determined using a machine learning algorithm based on information such as past task completion times, task types, and origins. For this machine learning algorithm, for example, scikit-learn's RandomForestClassifier is used.

[0449] In addition, the server has a means to organize tasks based on priority. It lists tasks in descending order of priority and presents them to the user. When an urgent task is inserted, it organizes the tasks again and presents the organized tasks to the user.

[0450] The server also has a means for adjusting task priorities based on the user's emotional state using an emotion engine. If the server recognizes that the user is stressed, the emotion engine increases the priority of tasks that may reduce the stress. If the server recognizes that the user is relaxed, the emotion engine increases the priority of tasks that require concentration. The emotion engine recognizes the user's emotional state based on data from sensors, for example.

[0451] In addition, the server has a means to recognize the robot's status based on data from the robot's sensors and adjust task priorities. Based on data from the robot's temperature and vibration sensors, the server recognizes the robot's "status" and adjusts task priorities.

[0452] As a concrete example, consider the following cases where tasks occur in a factory: Task 1 is assembly work, has a completion time of 30 minutes, and originates from Line 1. Task 2 is inspection work, has a completion time of 20 minutes, and originates from Line 2. If the robot's sensors recognize a "relaxed" state, the priority of tasks that require concentration (e.g., inspection work) will increase.

[0453] An example of a prompt sentence might be:

[0454] "Please generate a Python program that recognizes the robot's status and adjusts task priorities based on data from the factory robot's sensors. Please include a function that uses a machine learning algorithm to determine priorities based on data such as the type of task and completion time, and adjusts priorities using an emotion engine."

[0455] In this way, efficient task management is possible, taking into account the user's emotional state and the robot's operating status.

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

[0457] Step 1:

[0458] The server receives tasks such as document review requests and preparations for meetings from the communication tools. As input, it receives task information (task name, completion time, origin, etc.) from the communication tools and stores it in an internal database. As output, the received task information is stored in the database.

[0459] Step 2:

[0460] The server determines the priority of tasks from past records. As input, past task data (completion time, task type, origin, etc.) is input to a machine learning algorithm. As data processing, this data is extracted as features, and the priority is predicted using a machine learning model (e.g., Random Forest Classifier). As output, the priority of each task is determined.

[0461] Step 3:

[0462] The server organizes tasks based on priority. As input, it receives the prioritized task list determined in step 2. As data operation, it sorts the tasks in descending order of priority. As output, it produces the organized task list.

[0463] Step 4:

[0464] The server re-orders tasks when an urgent injecting task is received. As input, it takes the newly received urgent task information and adds it to the existing task list. As data operation, it re-evaluates the priority of all tasks and re-sorts them. As output, it generates an updated task list.

[0465] Step 5:

[0466] The server uses an emotion engine to adjust task priorities based on the user's emotional state. As input, it receives the user's emotional state data (e.g., stress level and relaxation level from sensors). As data processing, it adjusts the priority of certain tasks according to the emotional state. As output, a task list reflecting the emotional state is generated.

[0467] Step 6:

[0468] The server recognizes the robot's status based on data from the robot's sensors and adjusts task priorities. As input, it receives the robot's sensor data (temperature, vibration, etc.). As data processing, it analyzes this data and recognizes the robot's status. As data calculation, it readjusts task priorities according to the robot's status. As output, it generates a task list that reflects the robot's status.

[0469] Step 7:

[0470] The server presents the organized tasks to the user. As input, it receives the final organized task list. As a concrete operation, it displays the task list through a user interface. As output, it presents the task list in a form that the user can view.

[0471] Step 8:

[0472] The server records the user's task execution status. As input, it receives timestamp data when the user starts, finishes, and interrupts a task. As data processing, it records this data and reflects it in the next priority decision. As output, the execution status is saved in the database.

[0473] Example 2

[0474] Next, a second embodiment of the second embodiment will be described. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0475] In conventional task management systems, it is difficult to properly determine the priority of tasks, and there is a lack of means to reorganize tasks when an urgent task is inserted. In addition, the method of presenting tasks according to the user's emotional state is not taken into consideration, which increases the burden on the user and reduces productivity.

[0476] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving a task from a communication tool, a means for analyzing the content, transmission time, and sender of the received task, a means for acquiring past task data, a means for calculating the priority of a new task based on the past task data, a means for organizing tasks based on the priority, a means for presenting the organized tasks to the user, a means for recording the start and completion of the user's tasks, a means for reorganizing tasks when an urgent insertion task is received, and a means for adjusting the method of presenting tasks based on the user's emotional state. This makes it possible to appropriately determine the priority of tasks and quickly reorganize tasks even when an urgent task is received. In addition, by adjusting the method of presenting tasks according to the user's emotional state, it becomes possible to reduce the burden on the user and improve productivity.

[0477] A "Communication Tool" is any software or platform that enables users to exchange messages or information between each other.

[0478] A "task" is a specific task or activity that a user must complete.

[0479] "Means of receiving" refers to the functions and methods for obtaining information or data from outside.

[0480] "Means of analysis" refers to the functions and methods for understanding received information or data and extracting the necessary elements.

[0481] "Past Task Data" means information or records relating to tasks previously performed.

[0482] "Means of acquisition" refers to the functions or methods for collecting specific information or data.

[0483] A "means for calculating priority" is a function or method for evaluating the importance and urgency of tasks and determining their order.

[0484] An "organizing means" is a function or method for arranging tasks in a sequence based on specific criteria.

[0485] A "means of presentation" is a function or method for displaying information or data to a user.

[0486] A "means of recording" is a function or method for storing specific information or data.

[0487] An "urgent in-place task" is a task that arises suddenly and requires a quick response.

[0488] "Emotional state" refers to a user's psychological state or mood.

[0489] An "adjustment means" is a function or method for changing a method or setting based on certain conditions.

[0490] This invention is a system that receives tasks from a communication tool, calculates priorities based on past task data, and presents them to the user. It also has a function to adjust the way tasks are presented depending on the user's emotional state.

[0491] Hardware and Software Used

[0492] The server uses the following hardware and software to realize the system:

[0493] Hardware: Servers, terminals (users' PCs and smartphones)

[0494] Software: Python, Slack API, natural language processing libraries (e.g. spaCy), databases (e.g. MySQL), machine learning libraries (e.g. scikit-learn), web application frameworks (e.g. Flask)

[0495] Program Processing

[0496] The server receives messages from Slack using the Slack API. It uses a natural language processing library to analyze the content, sent time, and sender of the received messages. Based on the analyzed information, it retrieves past task data from the database. It uses a machine learning model to calculate the priority of new tasks based on the past task data.

[0497] Tasks with calculated priorities are organized based on their priority and presented to the user's browser using a web application framework. When the user starts a task, the device records the time and again when the task is completed. This information is sent to the server and stored in a database.

[0498] If an urgent task is inserted, the server reprioritizes the task list, including the task, and updates the task list. In addition, the server uses an emotion engine to recognize the user's emotional state, and presents tasks one at a time if the user is feeling impatient, and presents multiple tasks simultaneously if the user is calm.

[0499] Examples

[0500] As a concrete example, consider a case where a user receives a message in Slack saying "Please create documentation for a new project." This message is sent to the server, which processes it as follows:

[0501] 1. The server receives the message via the Slack API.

[0502] 2. Extract the message content “Create materials for a new project”, the sent time, and the sender.

[0503] 3. Obtain past task data related to "Document creation" from the database. For example, confirm that the average time required for "Document creation" is 2 hours.

[0504] 4. The server calculates the priority of the new task “Document Creation” based on past data. For example, it is determined to be high in importance and high in urgency.

[0505] 5. The server places the high priority task "Document Creation" at the top of the list and displays it in the user's browser.

[0506] 6. When the user starts "creating a document", the device records the start time. When the task is completed, the device records the completion time.

[0507] 7. If an urgent task called "Prepare for emergency meeting" is added, the server recalculates the priority to include that task and updates the task list.

[0508] 8. If the server uses the emotion engine to determine that the user is feeling anxious, it presents the "Create materials" task one by one. If the server determines that the user is calm, it presents the "Create materials" and "Prepare for an emergency meeting" tasks simultaneously.

[0509] Examples of prompt statements

[0510] If you receive a message in Slack saying, "Please create materials for a new project," calculate the priority of this task and present it to the user in a list with other tasks.

[0511]

[0512] If the user is feeling rushed, present them with one task at a time. If the user is calm, present them with multiple tasks at once.

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

[0514] Step 1: Receiving a message

[0515] The server receives messages from Slack using the Slack API. Specifically, it uses the Slack event API to obtain messages sent from specific channels and users in real time. The input is a message from Slack, and the output is the received message data.

[0516] Step 2: Parsing the message

[0517] The server analyzes the content, sending time, and sender of received messages. It uses a natural language processing library (e.g., spaCy) to extract task content from the message text. The input is the received message data, and the output is the analyzed task content, sending time, and sender information.

[0518] Step 3: Retrieve past task data

[0519] The server retrieves past task data from a database (e.g. MySQL). Specifically, it queries how similar tasks have been performed in the past, their duration and completion status. The input is the parsed task content, and the output is the past task data.

[0520] Step 4: Task Priority Calculation

[0521] The server calculates the priority of new tasks based on past task data. It uses a machine learning model (e.g., scikit-learn) to evaluate the importance and urgency of tasks. The input is the past task data, and the output is the calculated task priority.

[0522] Step 5: Generate and present the task list

[0523] The server lists tasks in order of priority and presents them to the user. A web application framework (e.g. Flask) is used to display the task list in the user's browser. The input is the calculated task priorities, and the output is the task list presented to the user.

[0524] Step 6: Recording task initiation and completion

[0525] When a user starts a task, the device records the time. When the task is completed, the device records the time again. This information is sent to a server and stored in a database. The inputs are the user's actions to start and complete the task, and the outputs are the recorded start and completion times.

[0526] Step 7: Handle urgent tasks

[0527] If an urgent task is inserted, the server re-determines the priority including the urgent task. The server updates the task list and presents it to the user again. The input is the urgent task information, and the output is the updated task list.

[0528] Step 8: Adjust task presentation with emotion engine

[0529] The server uses an emotion engine to recognize the user's emotional state. If the user feels anxious, it presents tasks one by one, and if the user feels calm, it presents multiple tasks simultaneously. The input is the user's emotional state, and the output is the adjusted task presentation method.

[0530] (Application example 2)

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

[0532] Conventional task management systems could not take into account the user's status or environment when determining task priorities, making it difficult to complete tasks efficiently. In addition, when an urgent intervening task occurred, tasks had to be reorganized manually, making it difficult to respond quickly. Furthermore, the system lacked the functionality to adjust the way tasks were presented depending on the robot's status, hindering efficient operation of the robot.

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

[0534] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool and preparation for a meeting, a means for determining task priority from past records, a means for organizing tasks based on priority, a means for reorganizing tasks when an urgent insertion task is received, a means for adjusting the method of presenting tasks based on the state of the robot, a means for monitoring the state of the robot, and a means for recording the execution time of tasks. This makes it possible to efficiently determine task priority and present optimal tasks according to the state of the robot.

[0535] A "Communication Tool" is any software or platform that enables users to exchange messages or information between each other.

[0536] A "document review request" is a task to review a specific document or data and request feedback or corrections.

[0537] "Preparing for a meeting" is the task of collecting and organizing the materials and information necessary for the meeting.

[0538] A "task" is a sequence of operations or activities performed to accomplish a particular goal.

[0539] "Past records" are data or information about previously performed tasks and their results.

[0540] "Priority" is an indicator of the importance and urgency of a task.

[0541] "Organization" is the process of efficiently managing tasks and determining the order in which they are to be performed.

[0542] An "urgent inject task" is a task that arises unexpectedly and requires immediate attention.

[0543] "Robot status" is information that indicates the operating status of the robot, such as the remaining battery level and temperature.

[0544] "Task presentation method" refers to how the task is displayed or communicated to the user or robot.

[0545] "Monitoring" is the process of continually checking the status and operation of a robot and responding if necessary.

[0546] "Execution time" is the time it takes from start to finish of a task.

[0547] An embodiment of the present invention will be described.

[0548] The server has a means for receiving tasks such as a request to review documents or preparation for a meeting from the communication tool. This means is realized, for example, by acquiring messages using the Slack API. The server extracts information such as the task content, sender, and sending time from the acquired messages.

[0549] Next, the server has a means for determining the priority of a task from past records. This means uses an algorithm that refers to past task data and evaluates the importance and urgency of the task. For example, the server determines the priority based on data such as how quickly similar tasks were processed in the past and how much resources were required.

[0550] The server further includes a means for sorting tasks based on priority. This means lists tasks in descending order of priority and generates a list to be presented to a user or a robot. When an urgent insertion task is received, the server sorts the tasks again and reevaluates the priorities.

[0551] The server is also equipped with a means for adjusting the way tasks are presented based on the robot's status. This means monitors the robot's operating conditions, such as the remaining battery level and temperature, and changes the way tasks are presented depending on the robot's status. For example, when the robot's battery is low, tasks are presented one at a time, reducing the burden on the robot. On the other hand, when the robot is operating normally, multiple tasks are presented simultaneously, improving productivity.

[0552] The server also includes a means for recording the execution time of a task. This means records the start and end times of a task and reflects the results in the next priority determination. This allows the efficiency of task execution to be continuously improved.

[0553] As a concrete example, consider the case where a task "Assemble part A" is sent from Slack. The server receives this message and determines the priority based on past data. If the robot's battery level is 50% and the temperature is 60 degrees, the server judges the robot's condition to be "normal" and presents multiple tasks simultaneously. The robot performs the presented tasks, and the server records the execution time.

[0554] Example of a prompt to be input to a generative AI model:

[0555] Create a program that receives messages from Slack, determines the priority of tasks, and presents tasks according to the robot's status. The robot's status includes the remaining battery level and temperature. Task priority is determined by referring to past data, and tasks are presented one at a time or multiple at the same time according to the robot's status.

[0556] In this way, the server can efficiently determine task priorities and present optimal tasks according to the robot's state.

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

[0558] Step 1:

[0559] The server receives messages from the communication tool. Specifically, it retrieves messages from a specified channel using the Slack API. The input is the message data from the Slack API, and the output is information such as the message content, sender, and sending time.

[0560] Step 2:

[0561] The server extracts the task contents from the received message. The input is the message data obtained in step 1, and the output is detailed information such as the task contents, sender, and sending time. Specifically, the server analyzes the text part of the message and extracts the parts that are recognized as tasks.

[0562] Step 3:

[0563] The server determines the task priority from past records. The input is the detailed task information extracted in step 2 and past task data, and the output is the task priority. Specifically, the server refers to the past task database and calculates the priority based on data such as how quickly similar tasks were processed and how many resources were required.

[0564] Step 4:

[0565] The server organizes tasks based on priority. The input is the task priority determined in step 3, and the output is a task list organized by priority. Specifically, it lists tasks in descending order of priority and generates a list to present to the user or robot.

[0566] Step 5:

[0567] The server reorganizes tasks when an urgent task is inserted. The input is the newly received urgent task information and the existing task list, and the output is the reorganized task list. Specifically, the priority of the urgent task is immediately evaluated and it is incorporated into the existing task list.

[0568] Step 6:

[0569] The server adjusts the task presentation method based on the robot's status. The input is the robot's status information (battery level, temperature, etc.) and the task list organized in step 4 or step 5, and the output is the adjusted task presentation method. Specifically, it monitors the robot's status, and if the battery is low, it presents tasks one by one, and if the battery is normal, it presents multiple tasks simultaneously.

[0570] Step 7:

[0571] The server records the execution time of a task. The input is the start and end time of the task, and the output is a record of the execution time. Specifically, it records the timestamps when the task is started and when it is completed, calculates the difference between them, and saves the execution time in the database.

[0572] In this way, the server can efficiently determine task priorities and present optimal tasks according to the robot's state.

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

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

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

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

[0577] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0590] "Example 1"

[0591] The embodiment of the present invention is a system that cooperates with a communication tool using an API, Webhook, etc., as a means for receiving tasks such as a request to review materials from the communication tool or preparation for a meeting. As a means for determining the priority of a task from past records, the priority is automatically determined using a machine learning algorithm based on information such as the completion time of the past task, the type of task, and the source of the task. As a means for organizing tasks based on priority, tasks are listed in descending order of priority and presented to the user. When an urgent insertion task is received, the tasks are organized again, and the organized tasks are presented to the user. In addition, as a means for recording the execution status of a user's task, the start time, end time, interruption time, etc. of the task are recorded, and the information is reflected in the next priority determination.

[0592] "Example 2"

[0593] As a specific example, consider a system that uses Slack as a communication tool and receives messages from Slack via an API. Based on the task content contained in the message, the time the message was sent, the sender, and other information, the system refers to the completion status of similar tasks in the past and determines the priority of a new task. Tasks are listed in order of highest priority and presented to the user. If an urgent insert task is received, the priority is determined again, including this task, and the task list is updated. When a user starts a task, the time is recorded, and when the task is completed, the time is recorded. This information is reflected in the next priority determination.

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

[0595] "Example 1"

[0596] Step 1: Receive tasks such as document review requests and meeting preparations from communication tools using APIs, Webhooks, etc.

[0597] Step 2: Based on the content of the received task, the time it was sent, the sender, and other information, the completion status of similar tasks in the past is referenced and the priority of the new task is determined.

[0598] Step 3: Present a list of tasks to the user, starting with the highest priority.

[0599] Step 4: If an urgent merge task comes in, reprioritize and update the task list to include that task.

[0600] Step 5: When a user starts a task, record the time, and when the task is completed, record the time. Use this information to inform the next priority decision.

[0601] "Example 2"

[0602] Step 1: Use Slack as a communication tool and receive messages from Slack via the API.

[0603] Step 2: Based on the task content contained in the message, the time the message was sent, the sender, and other information, the completion status of similar tasks in the past is referenced and the priority of the new task is determined.

[0604] Step 3: Present a list of tasks to the user, starting with the highest priority.

[0605] Step 4: If an urgent merge task comes in, reprioritize and update the task list to include that task.

[0606] Step 5: When a user starts a task, record the time, and when the task is completed, record the time. Use this information to inform the next priority decision.

[0607] Example 1

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

[0609] Conventional task management systems have difficulty efficiently receiving tasks from communication tools, properly determining priorities, and presenting them to users. They also lacked the functionality to reorganize tasks when an urgent insertion task occurs, or the functionality to record the user's task completion status and reflect it in the next priority determination. This made task management cumbersome for users and hindered efficient task completion.

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

[0611] In this invention, the server includes a means for receiving tasks from a communication tool, a means for analyzing the contents of the received tasks, a means for collecting past task data, a means for determining task priorities using a machine learning algorithm, a means for organizing tasks based on priorities, a means for reorganizing tasks when an urgent insertion task is received, a means for presenting the organized task list to the user, a means for recording the user's task performance status, and a means for reflecting the recorded performance status in the next priority determination. This makes it possible to consistently perform tasks from receiving them to determining priorities, organizing them, presenting them, and recording their performance status, thereby making the user's task management more efficient.

[0612] A "Communication Tool" is software or a platform that enables a user to exchange information with other users. Examples include messaging applications and video conferencing systems.

[0613] A "task" is a specific task or activity that a user needs to accomplish. Examples include requesting a document for review or preparing for a meeting.

[0614] A "server" is a computer system that processes data and provides services to other devices over a network.

[0615] "API" stands for Application Program Interface, a set of rules and tools for exchanging data and functions between different software programs.

[0616] A "Webhook" is a mechanism that sends an HTTP request to a specified URL when a specific event occurs.

[0617] A "machine learning algorithm" is a computational method for learning patterns from data and making predictions or classifications. Examples include random forests and support vector machines.

[0618] "Priority" is an indicator of the importance or urgency of a task. A task with a high priority should be completed before other tasks.

[0619] A "task list" is a list of tasks that a user needs to complete, organized according to priority.

[0620] "Performance status" is information that describes how a user is progressing through a task. Examples include the start time, end time, and interruption time of the task.

[0621] A "database" is a system for efficiently storing, searching, and managing data.

[0622] The present invention is a system for efficiently receiving tasks from a communication tool, appropriately determining priorities, and presenting them to a user. A specific embodiment of this system will be described below.

[0623] The server receives tasks from communication tools (e.g. messaging applications and video conferencing systems) using APIs or Webhooks. For example, you can set up a Slack Webhook to get task information when a new message is posted.

[0624] The server analyzes the received task contents using natural language processing (NLP) technology. For example, it extracts keywords such as "review request" or "meeting preparation" from the task title and description.

[0625] The server then collects historical task data from the database, for example using a SQL query to get the completion time and origin of review tasks for the past year.

[0626] The collected past task data is input into a machine learning algorithm (e.g., random forest or support vector machine) to predict the priority of new tasks. For example, the past data is input as features into the model, and a priority score is output.

[0627] The server sorts the tasks based on the priority score and lists them in descending order of priority, i.e., placing tasks with a higher priority score at the top of the list.

[0628] The organized task list is sent from the server to the terminal and presented to the user. The terminal displays the task list to the user and encourages the user to tackle the tasks in order of priority.

[0629] If an urgent injecting task occurs, the server re-organizes the tasks, e.g., when a new urgent task is added, it recalculates the existing task list and sends the updated list to the terminal.

[0630] The time when a user starts, finishes, or stops a task is recorded by the device. For example, when a user presses the "start button" to start a task, the start time is recorded.

[0631] The recorded performance data is sent to the server and reflected in the next priority decision. For example, the task completion time and interruption time are used as training data for the next machine learning model.

[0632] Examples

[0633] Example 1: Requesting a document review

[0634] A user receives a message on Slack saying, "Please review the document." The server receives this message and determines the priority based on the data of past review tasks. If the priority is high, the server notifies the device, "Please give priority to reviewing the document."

[0635] Example 2: Preparing for a meeting

[0636] A user receives a task in Microsoft Teams saying, "Please prepare for tomorrow's meeting." The server receives this task and determines the priority based on the data of past meeting preparation tasks. If the priority is low, the server notifies the device, "Please postpone preparation for the meeting."

[0637] Examples of prompt statements

[0638] "Please prioritize review requests for materials received via Slack. Determine the priority based on the completion time of past review tasks, the type of task, and the source of the task. If the request is high priority, notify the user."

[0639] In this way, we have specifically explained how the server, terminal, and user work together to determine and organize task priorities and present them to the user.

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

[0641] Step 1:

[0642] The server receives tasks from the communication tool using an API or Webhook.

[0643] Input: Task information from communication tools (e.g. Slack messages)

[0644] Output: Received task information

[0645] Specific operation: The server sets up a Slack webhook and receives the contents of a new message when it is posted. For example, it receives a message saying "Please review the document."

[0646] Step 2:

[0647] The server analyzes the contents of the received task.

[0648] Input: Received task information

[0649] Output: Information about the parsed tasks, such as type, origin, and deadline

[0650] Specific operation: The server uses natural language processing (NLP) technology to extract keywords such as "review request" and "meeting preparation" from the task title and description. For example, the server extracts the keyword "review request" from the message "Please review the materials."

[0651] Step 3:

[0652] The server collects past task data from a database.

[0653] Input: Information about the parsed task, such as type, origin, and due date

[0654] Output: Historical task data (e.g. completion time, task type, origin)

[0655] Specific operation: The server uses an SQL query to retrieve the completion time and origin of review tasks from the database over the past year. For example, it collects past task data related to "review requests."

[0656] Step 4:

[0657] The server uses machine learning algorithms to prioritize new tasks based on the past task data it has collected.

[0658] Input: Past task data

[0659] Output: The priority score of the new task.

[0660] Specific operation: The server uses machine learning algorithms such as random forests and support vector machines to input past data as features into a model and output a priority score. For example, it calculates the priority score for a "review request."

[0661] Step 5:

[0662] The server organizes the tasks based on the priority score, listing them in order of priority.

[0663] Input: The priority score of the new task

[0664] Output: An organized task list

[0665] Specific behavior: The server will place tasks with higher priority scores at the top of the list. For example, if "review request" has a high priority score, it will be placed at the top of the list.

[0666] Step 6:

[0667] The server transmits the organized task list to the terminal and presents it to the user.

[0668] Input: An organized task list

[0669] Output: The task list presented to the user.

[0670] Specific operation: The server sends the organized task list to the terminal, and the terminal displays the task list to the user. For example, the user's screen displays "request review" as the top priority task.

[0671] Step 7:

[0672] The server re-arranges tasks if an urgent merge task occurs.

[0673] Input: Urgent mail merge task information

[0674] Output: Updated task list.

[0675] Specific operation: The server recalculates the existing task list when a new urgent task is added and sends the updated list to the terminal. For example, if "urgent meeting preparation" is added, the task list is reorganized.

[0676] Step 8:

[0677] The device records the time when a user starts, finishes, and stops a task.

[0678] Input: User task performance (start time, end time, interruption time)

[0679] Output: Logged performance data

[0680] Specific operation: When a user starts a task, the device records the start time by pressing the "Start" button. Similarly, when the user finishes the task, the device records the end time by pressing the "End" button.

[0681] Step 9:

[0682] The server reflects the recorded performance data in the next priority determination.

[0683] Input: Recorded performance data

[0684] Output: An updated machine learning model.

[0685] Specific operation: The server stores the progress data received from the terminal in a database and uses it as training data for the next machine learning model, for example, to reflect the task completion time and interruption time in the next priority determination.

[0686] (Application example 1)

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

[0688] Conventional factory robots required manual task prioritization, making efficient task management difficult. In addition, when an urgent intervening task occurred, it was difficult to quickly reset task priorities, which could result in work delays and reduced efficiency. Furthermore, there was an insufficient means of recording the task execution status, making it impossible to reflect this in the next task priority determination.

[0689] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means. In this invention, the server includes a means for receiving tasks such as a request for reviewing materials from a communication tool and preparation for a meeting, a means for determining the priority of tasks from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for receiving tasks from a management system or a communication tool in a factory, a means for determining the priority of tasks using a machine learning algorithm based on past task data, a means for listing tasks in order of priority and presenting them to a robot, and a means for recording the start time, end time, interruption time, etc. of a task and reflecting them in the next priority determination. This enables the factory robot to efficiently manage tasks and quickly respond to urgent tasks, thereby preventing work delays and efficiency declines.

[0690] A "communication tool" is software or an application that allows users to exchange information between each other.

[0691] A "material review request" is a request to review and provide feedback on specific documents or data.

[0692] "Preparing for a meeting" refers to the task of gathering the materials and information necessary to ensure the meeting proceeds smoothly.

[0693] A "task" is an operation or activity that must be performed to achieve a particular purpose.

[0694] "Past records" are data about previously performed tasks and their results.

[0695] "Priority" is an indicator of the importance and urgency of a task.

[0696] A "machine learning algorithm" is a computational technique for learning patterns from data and making predictions or classifications.

[0697] "Factory management systems" is a general term for software and hardware used to manage factory operations and production activities.

[0698] The "start time of a task" is the time when the task actually starts.

[0699] "Task end time" is the time when the task is completed.

[0700] A "task suspension time" is a period of time during which a task is temporarily stopped.

[0701] A "robot" is a mechanical device that performs specific tasks automatically.

[0702] "Task progress status" is information that indicates the state or progress of a task.

[0703] A system for carrying out the present invention includes an application installed on a robot used in a factory. A specific embodiment of this system will be described below.

[0704] System Configuration

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

[0706] 1. Communication tools: Software or applications that allow users to exchange information between each other.

[0707] 2. Factory management systems: Software and hardware for managing factory operations and production activities.

[0708] 3. Robot: A mechanical device used to perform specific tasks automatically.

[0709] 4. Server: A central processing unit for receiving tasks, determining priorities, organizing tasks, and recording their execution status.

[0710] Program Processing

[0711] The server processes the data in the following steps:

[0712] 1. Receiving a task:

[0713] The server receives tasks from the factory's management system and communication tools, and the tasks to be executed by the robots are then consolidated on the server.

[0714] 2. Prioritization:

[0715] The server uses a machine learning algorithm to determine task priorities based on past task data. Specifically, it uses information such as past task completion times, task types, and origins as input data and predicts priorities using a generative AI model.

[0716] 3. Organize your tasks:

[0717] The server lists tasks in order of priority and presents them to the robot, allowing the robot to complete the tasks efficiently.

[0718] 4. Recording task completion status:

[0719] The server records the start time, end time, interruption time, etc. of the task and reflects this in the next priority determination, thereby improving the accuracy of task management.

[0720] Hardware and Software Used

[0721] Hardware: Factory robots, servers

[0722] Software: Python, scikit-learn (machine learning library), requests (HTTP request library)

[0723] Examples

[0724] For example, if a robot in a factory receives an "assembly task" and an "inspection task," past data will determine that the "assembly task" has a higher priority. The robot will carry out the "assembly task" first, and then the "inspection task." In this way, the robot can efficiently manage tasks and quickly respond to emergency tasks.

[0725] Examples of prompt statements

[0726] Design a system that automatically prioritizes tasks received by robots in factories and allows them to complete tasks efficiently. Use a machine learning algorithm to determine priorities based on past task data, and give the system the ability to list tasks in order of priority and present them to the robots. Also, add a function to record the task completion status and reflect it in the next priority determination.

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

[0728] Step 1:

[0729] The server receives tasks from the management system and communication tools in the factory. Specifically, it obtains task data from the API using an HTTP request. The input includes detailed task information (task ID, task content, origin, etc.). The output is that the received task data is stored in the server.

[0730] Step 2:

[0731] The server uses a machine learning algorithm to determine task priorities based on past task data. Specifically, it uses information such as past task completion times, task types, and origins as input data and predicts priorities using a generative AI model. The inputs include past task data and new task data. The output is the priority of each task.

[0732] Step 3:

[0733] The server lists tasks in descending order of priority and presents them to the robot. Specifically, the server sorts the tasks in descending order of priority and sends them to the robot in list form. The input includes task data with the determined priorities. The output is the sorted task list presented to the robot.

[0734] Step 4:

[0735] The robot performs tasks based on the presented task list. Specifically, it executes the tasks from the top of the list and records the start and end times of the tasks. The input includes a sorted task list. The output records the execution results of the performed tasks and their timestamps.

[0736] Step 5:

[0737] The server records the task execution status and reflects it in the next priority decision. Specifically, the start time, end time, interruption time, etc. of the task are stored in a database and used as training data for the next machine learning model. The input includes the execution result and timestamp of the completed task. The output is an updated task database.

[0738] Example 2

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

[0740] In conventional task management systems, it was difficult to properly determine the priority of tasks received from communication means and to reorganize tasks when an urgent insertion task occurred. In addition, there was a lack of functionality to record the user's task execution status and reflect it in the next priority determination, making it impossible to achieve efficient task management.

[0741] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving a task from a communication means, a means for saving information on the received task, a means for determining the priority of the task from past records, a means for organizing the tasks based on the priority, a means for reorganizing the tasks when an urgent insertion task is received, a means for recording the start time and completion time of the user's task, and a means for reflecting the recorded information in the next priority determination. This makes it possible to appropriately determine the priority of the task, quickly respond to an emergency task, and efficiently manage tasks reflecting the user's performance status.

[0742] A "communication means" is a device or system for sending and receiving information via a network.

[0743] A "task" is an operation or activity that must be performed to achieve a particular goal.

[0744] A "receiving means" is a function or process for obtaining information sent from a communication means.

[0745] "Means of storage" refers to the functions or processes for recording received information in a database or storage.

[0746] "Past records" refers to previously saved task status and related information.

[0747] A "prioritization method" is a function or process for evaluating and ranking the importance and urgency of tasks.

[0748] "Organizing tools" are functions or processes that sort tasks based on determined priorities and make them more manageable.

[0749] An "urgent in-place task" is a task that arises unexpectedly and requires immediate attention.

[0750] A "means for re-ordering tasks" is a function or process for re-evaluating and re-ordering the priority of existing tasks when an urgent insert task arises.

[0751] "Start time" is the time when the user begins the task.

[0752] "Completion Time" is the time when a user completes a task.

[0753] A "means for recording" is a function or process for recording the start time and completion time of a task in a database or storage.

[0754] "Means for reflecting in next priority determination" refers to a function or process for more accurately evaluating the priority of the next task based on the recorded information.

[0755] A "generative AI model" is a model that uses artificial intelligence to analyze data and is trained to perform a specific task.

[0756] This invention relates to a task management system that can appropriately determine the priority of tasks received from communication means and can quickly respond to urgent tasks. Furthermore, it records the task execution status of users and reflects it in the next priority determination, thereby realizing efficient task management.

[0757] Hardware and Software Used

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

[0759] Software: communication tools (e.g. messaging applications), communication APIs, databases (e.g. MySQL), generative AI models (e.g. GPT-4)

[0760] System Overview

[0761] 1. Receiving a Message

[0762] The server receives the task sent from the communication means using the communication means API.

[0763] For example, the server may receive a task to "create a proposal for a new project."

[0764] 2. Data storage

[0765] The server stores the received task contents, sending time, and sender information in a database.

[0766] For example, the task content “Create a proposal for a new project”, the sending time “2023-10-01 10:00:00”, and the sender “user123” are saved.

[0767] 3. Reference to past data

[0768] The server refers to a database for past execution status of similar tasks.

[0769] For example, it is referenced that the completion time of the past "Write proposal" task was "2023-09-25 15:00:00".

[0770] 4. Determining Priorities

[0771] The server uses a generative AI model (e.g. GPT-4) to prioritize new tasks.

[0772] For example, an AI model may rate the task "Create a proposal for a new project" as a "high" priority.

[0773] 5. Creating a task list

[0774] The server creates a task list by listing tasks in descending order of priority.

[0775] For example, on your task list you might write "1. Create a proposal for new project" and "2. Prepare for client meeting."

[0776] 6. Dealing with Urgent Tasks

[0777] If an urgent insertion task is received, the server will re-determine the priority including that task.

[0778] For example, if an urgent task such as "responding to a sudden inquiry from a client" comes in, the task list is updated.

[0779] 7. Recording when tasks are started and completed

[0780] When a user starts a task, the time is recorded from the device.

[0781] For example, if a user starts a task "Create a proposal for a new project" at 10:30 and completes it at 12:00, record that time.

[0782] 8. Reflection in the next priority decision

[0783] The server will use the recorded task start and completion times to determine the next priority.

[0784] For example, it can learn that past "proposal writing" tasks took an average of two hours and reflect that in determining the next priority.

[0785] Examples of prompt statements

[0786] "Please explain a system that determines the priority of tasks and generates a task list based on messages received from a communication means. Please explain the specific process flow and the hardware and software used."

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

[0788] Step 1:

[0789] Receiving messages

[0790] The server receives the task sent from the communication means using the communication means API.

[0791] Input: Message data from the communication medium (e.g. task content, sending time, sender)

[0792] Output: Received message data

[0793] What happens: The server sets up a communication API and listens for messages from a specific channel or user, for example, to receive a message saying "Create a proposal for a new project."

[0794] Step 2:

[0795] Data storage

[0796] The server stores information about the received message, including the content, time of sending, and sender in a database.

[0797] Input: Received message data

[0798] Output: Task information stored in a database

[0799] Specific operation: The server executes an INSERT statement in a database such as MySQL to save the data. For example, it saves the task content "Create a proposal for a new project", the sending time "2023-10-01 10:00:00", and the sender "user123".

[0800] Step 3:

[0801] View past data

[0802] The server refers to a database for past execution status of similar tasks.

[0803] Input: Past task data in the database

[0804] Output: Referenced past task data

[0805] Specific operation: The server executes a SELECT statement to obtain the completion time and priority of past "Write proposal" tasks. For example, it references that the completion time of the past "Write proposal" task was "2023-09-25 15:00:00".

[0806] Step 4:

[0807] Determining Priorities

[0808] The server uses a generative AI model (e.g. GPT-4) to prioritize new tasks.

[0809] Input: Referenced previous task data, new task data

[0810] Output: Determined task priority

[0811] How it works: The server inputs past data into the AI ​​model and evaluates the urgency and importance of the task. For example, the AI ​​model evaluates the task "Create a proposal for a new project" as a "high" priority.

[0812] Step 5:

[0813] Generate a task list

[0814] The server creates a task list by listing tasks in descending order of priority.

[0815] Input: Determined task priority

[0816] Output: task list

[0817] What it does: The server sorts the tasks based on priority and stores them in a database in list format. For example, a task list might read "1. Create a proposal for a new project" and "2. Prepare for a client meeting."

[0818] Step 6:

[0819] Dealing with Urgent Tasks

[0820] If an urgent insertion task is received, the server will re-determine the priority including that task.

[0821] Input: New urgent task data, existing task list

[0822] Output: Updated task list

[0823] Specific operation: The server inputs new tasks into the AI ​​model and reevaluates the overall priority. For example, if an urgent task such as "responding to an urgent inquiry from a client" is received, the task list is updated.

[0824] Step 7:

[0825] Recording task initiation and completion

[0826] When a user starts a task, the time is recorded from the device.

[0827] Input: Task start time, completion time

[0828] Output: Recorded task start and completion times

[0829] Specific operation: The user presses the "Start" button through the terminal interface, and the server saves the time in the database. When the task is completed, the user presses the "Finish" button in the same way, and the completion time is recorded. For example, if the user starts the task "Write a proposal for a new project" at 10:30 and completes it at 12:00, the time will be recorded.

[0830] Step 8:

[0831] Reflection in next priority decision

[0832] The server will use the recorded task start and completion times to determine the next priority.

[0833] Input: Recorded task start and completion times

[0834] Output: Data reflected in the next priority decision

[0835] How it works: The server inputs past execution times and completion status into the AI ​​model to more accurately evaluate the next task priority. For example, it learns that past "proposal writing" tasks took an average of two hours, and reflects this in determining the next priority.

[0836] (Application example 2)

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

[0838] In conventional task management systems, it was difficult to properly determine the priorities of complex tasks in a factory and to manage them efficiently. In addition, when an urgent task occurred, it was not possible to quickly update the task list and reset the appropriate priority. Furthermore, there was a lack of a mechanism to record the task execution status and reflect it in the next priority determination, which led to a problem of reduced overall work efficiency.

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

[0840] In this invention, the server includes a means for receiving tasks such as a request for reviewing materials from a communication tool or preparation for a meeting, a means for determining the priority of tasks from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for receiving task information from a management system in a factory, a means for analyzing information such as the content of a task, the sending time, and the sender, a means for recording the task start time and completion time, a means for determining the priority of a task using a generative AI model, and a means for generating a prompt sentence. This makes it possible to appropriately determine the priority of complex tasks in a factory and efficiently manage them. Furthermore, even if an urgent insertion task occurs, the task list can be quickly updated and the priority can be reset appropriately. In addition, by recording the progress of the tasks and reflecting it in the next priority determination, the overall work efficiency can be improved.

[0841] A "communication tool" is software or a platform that allows users to exchange messages or information between each other.

[0842] A "material review request" is a request to review specific documents or data and seek feedback or corrections.

[0843] "Preparing for a meeting" refers to the task of collecting and organizing the materials and information necessary to ensure the smooth running of the meeting.

[0844] A "task" is a unit of work or activity that must be performed to achieve a specific purpose.

[0845] "Past records" are data showing the progress and results of tasks previously performed.

[0846] "Priority" is an index of importance that indicates which of multiple tasks should be performed first.

[0847] "Organizing" is the act of classifying and arranging tasks based on certain criteria.

[0848] An "urgent inject task" is a task or activity that arises unexpectedly and requires immediate attention.

[0849] "Factory management systems" is a general term for software and hardware used to oversee and manage a factory's production activities and operations.

[0850] "Task information" is detailed data such as the task content, sending time, sender, and so on.

[0851] "Analysis" is the process of examining data or information in detail to clarify its meaning and structure.

[0852] "Task start time" is the time when a particular task actually begins.

[0853] "Task completion time" is the time when a particular task is actually completed.

[0854] A "generative AI model" is an algorithm or program that uses artificial intelligence technology to analyze data and generate new information or results.

[0855] A "prompt" is an instruction or question to be input into a generative AI model.

[0856] A system for carrying out the present invention is for linking with a management system within a factory, appropriately determining task priorities, and efficiently managing the tasks. A specific embodiment of the system will be described below.

[0857] System Configuration

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

[0859] 1. Server: Plays a central role in receiving task information, analyzing it, and determining priorities.

[0860] 2. Factory management system: A system that provides task information, such as an MES system.

[0861] 3. Generative AI Model: An artificial intelligence model used to prioritize tasks.

[0862] 4. User terminal: A device that displays the task list and allows the user to manage the progress of tasks.

[0863] Program Processing

[0864] The server receives task information from the factory's management system. The task information includes detailed data such as the task content, transmission time, and sender. The server analyzes this information and determines the priority of the task based on past records. A generative AI model is used to determine the priority.

[0865] The server organizes tasks based on priority and presents a task list to the user terminal. If an urgent insertion task occurs, the server determines the priority again and updates the task list. It records the time when the user starts and completes the task, and reflects this in the next priority determination.

[0866] Hardware and Software Used

[0867] Hardware: Factory robots (e.g. KUKA, Fanuc, etc.), user terminals (e.g. PCs, tablets)

[0868] Software: Python, API communication library (requests), generative AI model

[0869] Examples

[0870] For example, when a new task is sent from the management system in a factory, the server receives the task, determines its priority, and updates the task list. If an urgent maintenance task is received, the server gives priority to the task.

[0871] Examples of prompt statements

[0872] An example of a prompt to be input to the generative AI model is as follows:

[0873] A new task has been sent from the factory management system. The task content is "Maintenance of Machine A", the sending time is "2023-10-01T10:00:00", and the sender is "Administrator". Please determine the priority of this task and update the task list.

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

[0875] Step 1:

[0876] The server receives task information from the management system in the factory. The input is the task information sent from the management system, and the output is the received task information data. In concrete terms, the server obtains the task information through the API and stores details such as the task content, sending time, and sender in the database.

[0877] Step 2:

[0878] The server analyzes the received task information. The input is the task information received in step 1, and the output is the analyzed task details. In concrete terms, the server extracts information such as the task content, sending time, sender, etc., and stores these data in individual variables.

[0879] Step 3:

[0880] The server determines the priority of a task based on past records. The input is the analyzed task details and past task records, and the output is the determined task priority. In concrete terms, the server uses a generative AI model to refer to past task execution status and calculate the priority of the current task.

[0881] Step 4:

[0882] The server organizes tasks based on priority. The input is the determined task priority, and the output is the organized task list. In concrete terms, the server generates a task list according to the task priority and sorts the tasks by priority.

[0883] Step 5:

[0884] The server presents the organized task list to the user terminal. The input is the organized task list, and the output is the task list displayed on the user terminal. In specific operation, the server transmits the task list to the user terminal for the user to view.

[0885] Step 6:

[0886] When an urgent insertion task occurs, the server re-determines the priority and updates the task list. The input is the urgent insertion task information, and the output is the updated task list. In concrete terms, the server analyzes the newly received urgent task, re-determines the priority using the generative AI model, and updates the task list.

[0887] Step 7:

[0888] The user records the time when the task is started and completed. The input is the task information that the user reports as started and completed, and the output is the recorded task start and completion times. In concrete terms, the user presses a button when the task is started, and also presses a button when the task is completed, and the start and completion times are sent to the server.

[0889] Step 8:

[0890] The server reflects the recorded task performance status in the next priority determination. The input is the recorded task start time and completion time, and the output is the data to be used in the next priority determination. In concrete terms, the server stores the task performance time in a database and refers to this data when determining the next task priority.

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

[0892] "Example 1"

[0893] One embodiment of the present invention is a task management system incorporating an emotion engine. This system recognizes the emotions of a user and adjusts task priorities based on the user's emotional state. Specifically, if the emotion engine recognizes that the user is feeling stressed, it increases the priority of tasks that have the potential to reduce the stress. In addition, if the emotion engine recognizes that the user is relaxed, it increases the priority of tasks that require concentration. This allows the user to perform optimal tasks according to their emotional state.

[0894] "Example 2"

[0895] In another embodiment of the present invention, there is a system in which an emotion engine adjusts the way in which tasks are presented based on the emotional state of the user. Specifically, if the emotion engine recognizes that the user is feeling impatient, it presents tasks one by one, thereby reducing the burden on the user. On the other hand, if the emotion engine recognizes that the user is calm, it presents multiple tasks simultaneously, thereby improving the user's productivity. This makes it possible to present optimal tasks according to the user's emotional state.

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

[0897] "Example 1"

[0898] Step 1: The emotion engine recognizes the user's emotional state.

[0899] Step 2: Adjust the priority of tasks based on the emotional state recognized by the emotion engine. For example, if it recognizes that the user is feeling stressed, it will increase the priority of tasks that may reduce stress.

[0900] Step 3: Present tasks to users based on the adjusted priorities.

[0901] "Example 2"

[0902] Step 1: The emotion engine recognizes the user's emotional state.

[0903] Step 2: Based on the emotional state recognized by the emotion engine, adjust the way tasks are presented. For example, if it recognizes that the user is feeling impatient, present the tasks one by one. Step 3: Based on the adjusted presentation method, present the tasks to the user.

[0904] Example 1

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

[0906] Conventional task management systems cannot take into account the user's emotional state when determining task priorities, making it difficult to optimally manage tasks according to the user's stress and concentration. In addition, there are problems such as not being able to quickly reorganize tasks when an urgent insert task occurs, and lacking a function to record the user's task execution status and reflect it in the next priority determination.

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

[0908] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool or preparations for a meeting, a means for determining task priority from past records, a means for organizing tasks based on priority, a means for reorganizing tasks when an urgent insertion task is received, a means for recognizing the emotional state of a user and adjusting task priority based on the emotional state, a means for recording the start time, end time, interruption time, etc. of a user's task, and a means for presenting the organized tasks to the user. This enables optimal task management according to the emotional state of the user, and realizes rapid reorganization of urgent tasks, recording of task execution status, and reflection of the status in the next priority determination.

[0909] "Communication Tools" means software or platforms that Users use to exchange information with other Users.

[0910] A "task" refers to a specific task or activity that a user needs to accomplish.

[0911] "Priority" is an index of importance that indicates which task among multiple tasks should be performed first.

[0912] "Emotional state" refers to the user's psychological state and includes emotions such as stress or relaxation.

[0913] An "emotion engine" is an algorithm or software for recognizing a user's emotional state and adjusting the system's behavior based on that state.

[0914] "Task completion status" refers to information such as the time when a user started a task, the time when the user finished the task, and the time when the user stopped the task.

[0915] An "urgent inject task" is a high-priority task that is unexpectedly added to an existing task list.

[0916] A "database" is a system for storing information such as past task data and user performance status.

[0917] A "machine learning algorithm" is an algorithm that learns patterns based on past data and makes predictions and classifications for new data.

[0918] An "API" is an interface that allows different software systems to communicate with each other.

[0919] A "Webhook" is a mechanism that sends an HTTP request to a specified URL when a specific event occurs.

[0920] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0921] This invention is a system that receives tasks from a communication tool, determines the priority of the tasks based on past records and the emotional state of the user, and presents the organized tasks to the user. A specific embodiment of this system will be described below.

[0922] Receiving tasks from communication tools

[0923] The server receives tasks from communication tools (e.g. Slack, Microsoft Teams) using APIs or Webhooks. For example, by setting up a Slack Webhook, when a new message is posted in a specific channel, the server receives the content.

[0924] Parsing task information

[0925] The server parses the received message and extracts details such as task type, origin, deadline, etc. For example, when a message is posted saying "Please prepare for a meeting," the server extracts the task type "prepare for a meeting" and the origin "Slack."

[0926] Get past task data

[0927] The server retrieves information from the database about past task completion times, task types, origins, etc. For example, it checks how long similar tasks took to complete in the past.

[0928] Task Prioritization

[0929] The server uses machine learning algorithms (e.g., random forests, support vector machines) to prioritize new tasks based on past task data. For example, tasks that took a long time in the past are set to a higher priority.

[0930] Organizing and listing tasks

[0931] The server will organize the tasks based on priority and list them in order of priority, for example the "prepare for meeting" task will be at the top of the list as it has the highest priority.

[0932] Present tasks to users

[0933] The terminal presents the user with an organized task list. For example, the user's PC screen shows "Prepare for a meeting" as the top priority task.

[0934] Handling urgent tasks

[0935] If an urgent merge task occurs, the server reorganizes the tasks and sends the updated list to the terminal. For example, if an "urgent bug fix" occurs, that task is displayed at the top of the list as the highest priority.

[0936] Recording task completion status

[0937] The server records the start time, end time, interruption time, etc. of a user's task. For example, the server records the time when a "prepare for meeting" task was started and ended.

[0938] Prioritization using emotion engine

[0939] The server uses an emotion engine to recognize the user's emotional state and adjusts task priorities based on that state. For example, if the user is feeling stressed, it will increase the priority of the "reading materials" task, which is relaxing.

[0940] Examples of concrete examples and prompts

[0941] Examples

[0942] When a user uses Slack, a "prepare for a meeting" task is sent to the server via Slack's webhook. The server determines the priority based on the data of past meeting preparation tasks and lists them as high-priority tasks. If the emotion engine recognizes that the user is feeling stressed, it sets the "reading materials" task, which is relaxing, as a high priority.

[0943] Examples of prompt statements

[0944] "Try to prioritize meeting preparation tasks you receive from Slack, and if users are feeling stressed, prioritize tasks that will help them relax."

[0945] In this way, by explaining the system processing from the perspectives of the server, terminal, and user, the specific operations and technologies used become clear.

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

[0947] Step 1:

[0948] The server receives tasks from the communication tool using an API or Webhook.

[0949] Input: Task information from communication tools (e.g. Slack messages)

[0950] Output: Received task information

[0951] Specific operation: The server sets up a Slack webhook and receives the contents of a new message posted in a specific channel. For example, when a message "Please prepare for a meeting" is posted, the contents are sent to the server.

[0952] Step 2:

[0953] The server parses the received task information and extracts details such as the task type, origin, and deadline.

[0954] Input: Received task information

[0955] Output: Detailed information about the parsed tasks (task type, origin, deadline, etc.)

[0956] Specific operation: The server analyzes the received message, extracts the task type "prepare for meeting" and the source "Slack", and identifies the deadline from the date information included in the message.

[0957] Step 3:

[0958] The server retrieves information such as past task completion times, task types, and origins from the database.

[0959] Input: Task details

[0960] Output: Past task data

[0961] What happens: The server queries the database to get past completion times for "prepare for meeting" tasks and tasks originating from "Slack." For example, it checks how long similar tasks took to complete in the past.

[0962] Step 4:

[0963] The server uses machine learning algorithms to determine the priority of new tasks based on the past task data it has acquired.

[0964] Input: Past task data, detailed task information

[0965] Output: Determined task priority

[0966] How it works: The server uses a random forest algorithm to analyze past task data and determine the priority of new tasks. For example, tasks that took a long time in the past are set to a higher priority.

[0967] Step 5:

[0968] The server organizes tasks based on priority, listing them in descending order of priority.

[0969] Input: Determined task priority

[0970] Output: An organized task list

[0971] What happens: The server sorts the tasks based on priority and lists them in order of priority. For example, the "Prepare for meeting" task is the top priority and appears at the top of the list.

[0972] Step 6:

[0973] The terminal presents the user with an organized task list.

[0974] Input: An organized task list

[0975] Output: The task list presented to the user.

[0976] Specific operation: The terminal displays an organized task list on the user's PC screen. For example, "Prepare for meeting" is displayed as the top priority task.

[0977] Step 7:

[0978] If an urgent insertion task occurs, the server reorganizes the tasks and transmits an updated list to the terminal.

[0979] Input: Urgent mail merge task information

[0980] Output: Updated task list.

[0981] What it does: If an urgent merge task occurs, the server adds it to the list and sorts the tasks again based on priority. For example, if an "urgent bug fix" occurs, that task will be displayed at the top of the list as the highest priority.

[0982] Step 8:

[0983] The server records the start time, end time, interruption time, etc. of a user's task.

[0984] Input: User's task performance status

[0985] Output: Recorded task performance data

[0986] Specific operation: The server records the time when the user starts, finishes, and stops a task. For example, it records the time when the "prepare for meeting" task starts and ends.

[0987] Step 9:

[0988] The server uses an emotion engine to recognize the user's emotional state and adjusts task priorities based on that state.

[0989] Input: The user's emotional state

[0990] Output: Adjusted task priorities

[0991] Specific operation: The server uses the emotion engine to analyze the user's emotional state, and if the user is feeling stressed, it increases the priority of tasks that help the user relax. For example, if the server recognizes that the user is feeling stressed, it increases the priority of the "reading materials" task.

[0992] (Application example 1)

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

[0994] In conventional task management systems, the user's emotional state or the robot's operating status could not be taken into account when determining task priorities, making it difficult to carry out tasks efficiently. In addition, when an urgent intervening task occurs, tasks are often not reorganized promptly, resulting in a decrease in work efficiency.

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

[0996] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool and preparations for a meeting, a means for determining task priority from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for determining task priority using a machine learning algorithm, a means for adjusting task priority based on the emotional state of a user using an emotion engine, and a means for recognizing the state of the robot based on data from the robot's sensor and adjusting task priority. This enables efficient task management that takes into account the emotional state of the user and the operating status of the robot.

[0997] A "communication tool" is software or a platform that allows users to exchange information.

[0998] A "request for document review" is a task to check the contents of a specific document or data and ask for opinions or corrections.

[0999] "Preparing for a meeting" is the task of preparing the materials and information necessary to ensure the meeting proceeds smoothly.

[1000] A "task" is an operation or activity that must be performed to achieve a particular purpose.

[1001] "Past records" are data about previously performed tasks and their results.

[1002] "Priority" is an indicator of the importance and urgency of a task.

[1003] A "machine learning algorithm" is a computational technique that learns patterns from data and makes predictions and classifications.

[1004] An "emotion engine" is a technology for recognizing a user's emotional state and adjusting the system's behavior based on that.

[1005] A "robot" is a mechanical device that performs tasks automatically.

[1006] A "sensor" is a device that detects information about the physical environment and outputs it as data.

[1007] "Adjusting task priorities" means reevaluating the importance and urgency of tasks and changing the order of execution.

[1008] "Task organization" means classifying and ordering tasks in order to manage them efficiently.

[1009] An "urgent inject task" is a task that occurs unscheduled and requires immediate attention.

[1010] The system for carrying out the present invention is configured as follows: The server has a means for receiving tasks such as requests to review materials and preparations for meetings from communication tools, allowing the user to obtain tasks directly from the communication tool he or she is using.

[1011] Next, the server has a means to determine the priority of tasks from past records. Priorities are automatically determined using a machine learning algorithm based on information such as past task completion times, task types, and origins. For this machine learning algorithm, for example, scikit-learn's RandomForestClassifier is used.

[1012] In addition, the server has a means to organize tasks based on priority. It lists tasks in descending order of priority and presents them to the user. When an urgent task is inserted, it organizes the tasks again and presents the organized tasks to the user.

[1013] The server also has a means for adjusting task priorities based on the user's emotional state using an emotion engine. If the server recognizes that the user is stressed, the emotion engine increases the priority of tasks that may reduce the stress. If the server recognizes that the user is relaxed, the emotion engine increases the priority of tasks that require concentration. The emotion engine recognizes the user's emotional state based on data from sensors, for example.

[1014] In addition, the server has a means to recognize the robot's status based on data from the robot's sensors and adjust task priorities. Based on data from the robot's temperature and vibration sensors, the server recognizes the robot's "status" and adjusts task priorities.

[1015] As a concrete example, consider the following cases where tasks occur in a factory: Task 1 is assembly work, has a completion time of 30 minutes, and originates from Line 1. Task 2 is inspection work, has a completion time of 20 minutes, and originates from Line 2. If the robot's sensors recognize a "relaxed" state, the priority of tasks that require concentration (e.g., inspection work) will increase.

[1016] An example of a prompt sentence might be:

[1017] "Please generate a Python program that recognizes the robot's status and adjusts task priorities based on data from the factory robot's sensors. Please include a function that uses a machine learning algorithm to determine priorities based on data such as the type of task and completion time, and adjusts priorities using an emotion engine."

[1018] In this way, efficient task management is possible, taking into account the user's emotional state and the robot's operating status.

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

[1020] Step 1:

[1021] The server receives tasks such as document review requests and preparations for meetings from the communication tools. As input, it receives task information (task name, completion time, origin, etc.) from the communication tools and stores it in an internal database. As output, the received task information is stored in the database.

[1022] Step 2:

[1023] The server determines the priority of tasks from past records. As input, past task data (completion time, task type, origin, etc.) is input to a machine learning algorithm. As data processing, this data is extracted as features, and the priority is predicted using a machine learning model (e.g., Random Forest Classifier). As output, the priority of each task is determined.

[1024] Step 3:

[1025] The server organizes tasks based on priority. As input, it receives the prioritized task list determined in step 2. As data operation, it sorts the tasks in descending order of priority. As output, it produces the organized task list.

[1026] Step 4:

[1027] The server re-orders tasks when an urgent injecting task is received. As input, it takes the newly received urgent task information and adds it to the existing task list. As data operation, it re-evaluates the priority of all tasks and re-sorts them. As output, it generates an updated task list.

[1028] Step 5:

[1029] The server uses an emotion engine to adjust task priorities based on the user's emotional state. As input, it receives the user's emotional state data (e.g., stress level and relaxation level from sensors). As data processing, it adjusts the priority of certain tasks according to the emotional state. As output, a task list reflecting the emotional state is generated.

[1030] Step 6:

[1031] The server recognizes the robot's status based on data from the robot's sensors and adjusts task priorities. As input, it receives the robot's sensor data (temperature, vibration, etc.). As data processing, it analyzes this data and recognizes the robot's status. As data calculation, it readjusts task priorities according to the robot's status. As output, it generates a task list that reflects the robot's status.

[1032] Step 7:

[1033] The server presents the organized tasks to the user. As input, it receives the final organized task list. As a concrete operation, it displays the task list through a user interface. As output, it presents the task list in a form that the user can view.

[1034] Step 8:

[1035] The server records the user's task execution status. As input, it receives timestamp data when the user starts, finishes, and interrupts a task. As data processing, it records this data and reflects it in the next priority decision. As output, the execution status is saved in the database.

[1036] Example 2

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

[1038] In conventional task management systems, it is difficult to properly determine the priority of tasks, and there is a lack of means to reorganize tasks when an urgent task is inserted. In addition, the method of presenting tasks according to the user's emotional state is not taken into consideration, which increases the burden on the user and reduces productivity.

[1039] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving a task from a communication tool, a means for analyzing the content, transmission time, and sender of the received task, a means for acquiring past task data, a means for calculating the priority of a new task based on the past task data, a means for organizing tasks based on the priority, a means for presenting the organized tasks to the user, a means for recording the start and completion of the user's tasks, a means for reorganizing tasks when an urgent insertion task is received, and a means for adjusting the method of presenting tasks based on the user's emotional state. This makes it possible to appropriately determine the priority of tasks and quickly reorganize tasks even when an urgent task is received. In addition, by adjusting the method of presenting tasks according to the user's emotional state, it becomes possible to reduce the burden on the user and improve productivity.

[1040] A "Communication Tool" is any software or platform that enables users to exchange messages or information between each other.

[1041] A "task" is a specific task or activity that a user must complete.

[1042] "Means of receiving" refers to the functions and methods for obtaining information or data from outside.

[1043] "Means of analysis" refers to the functions and methods for understanding received information or data and extracting the necessary elements.

[1044] "Past Task Data" means information or records relating to tasks previously performed.

[1045] "Means of acquisition" refers to the functions or methods for collecting specific information or data.

[1046] A "means for calculating priority" is a function or method for evaluating the importance and urgency of tasks and determining their order.

[1047] An "organizing means" is a function or method for arranging tasks in a sequence based on specific criteria.

[1048] A "means of presentation" is a function or method for displaying information or data to a user.

[1049] A "means of recording" is a function or method for storing specific information or data.

[1050] An "urgent in-place task" is a task that arises suddenly and requires a quick response.

[1051] "Emotional state" refers to a user's psychological state or mood.

[1052] An "adjustment means" is a function or method for changing a method or setting based on certain conditions.

[1053] This invention is a system that receives tasks from a communication tool, calculates priorities based on past task data, and presents them to the user. It also has a function to adjust the way tasks are presented depending on the user's emotional state.

[1054] Hardware and Software Used

[1055] The server uses the following hardware and software to realize the system:

[1056] Hardware: Servers, terminals (users' PCs and smartphones)

[1057] Software: Python, Slack API, natural language processing libraries (e.g. spaCy), databases (e.g. MySQL), machine learning libraries (e.g. scikit-learn), web application frameworks (e.g. Flask)

[1058] Program Processing

[1059] The server receives messages from Slack using the Slack API. It uses a natural language processing library to analyze the content, sent time, and sender of the received messages. Based on the analyzed information, it retrieves past task data from the database. It uses a machine learning model to calculate the priority of new tasks based on the past task data.

[1060] Tasks with calculated priorities are organized based on their priority and presented to the user's browser using a web application framework. When the user starts a task, the device records the time and again when the task is completed. This information is sent to the server and stored in a database.

[1061] If an urgent task is inserted, the server reprioritizes the task list, including the task, and updates the task list. In addition, the server uses an emotion engine to recognize the user's emotional state, and presents tasks one at a time if the user is feeling impatient, and presents multiple tasks simultaneously if the user is calm.

[1062] Examples

[1063] As a concrete example, consider a case where a user receives a message in Slack saying "Please create documentation for a new project." This message is sent to the server, which processes it as follows:

[1064] 1. The server receives the message via the Slack API.

[1065] 2. Extract the message content “Create materials for a new project”, the sent time, and the sender.

[1066] 3. Obtain past task data related to "Document creation" from the database. For example, confirm that the average time required for "Document creation" is 2 hours.

[1067] 4. The server calculates the priority of the new task “Document Creation” based on past data. For example, it is determined to be high in importance and high in urgency.

[1068] 5. The server places the high priority task "Document Creation" at the top of the list and displays it in the user's browser.

[1069] 6. When the user starts "creating a document", the device records the start time. When the task is completed, the device records the completion time.

[1070] 7. If an urgent task called "Prepare for emergency meeting" is added, the server recalculates the priority to include that task and updates the task list.

[1071] 8. If the server uses the emotion engine to determine that the user is feeling anxious, it presents the "Create materials" task one by one. If the server determines that the user is calm, it presents the "Create materials" and "Prepare for an emergency meeting" tasks simultaneously.

[1072] Examples of prompt statements

[1073] If you receive a message in Slack saying, "Please create materials for a new project," calculate the priority of this task and present it to the user in a list with other tasks.

[1074]

[1075] If the user is feeling rushed, present them with one task at a time. If the user is calm, present them with multiple tasks at once.

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

[1077] Step 1: Receiving a message

[1078] The server receives messages from Slack using the Slack API. Specifically, it uses the Slack event API to obtain messages sent from specific channels and users in real time. The input is a message from Slack, and the output is the received message data.

[1079] Step 2: Parsing the message

[1080] The server analyzes the content, sending time, and sender of received messages. It uses a natural language processing library (e.g., spaCy) to extract task content from the message text. The input is the received message data, and the output is the analyzed task content, sending time, and sender information.

[1081] Step 3: Retrieve past task data

[1082] The server retrieves past task data from a database (e.g. MySQL). Specifically, it queries how similar tasks have been performed in the past, their duration and completion status. The input is the parsed task content, and the output is the past task data.

[1083] Step 4: Task Priority Calculation

[1084] The server calculates the priority of new tasks based on past task data. It uses a machine learning model (e.g., scikit-learn) to evaluate the importance and urgency of tasks. The input is the past task data, and the output is the calculated task priority.

[1085] Step 5: Generate and present the task list

[1086] The server lists tasks in order of priority and presents them to the user. A web application framework (e.g. Flask) is used to display the task list in the user's browser. The input is the calculated task priorities, and the output is the task list presented to the user.

[1087] Step 6: Recording task initiation and completion

[1088] When a user starts a task, the device records the time. When the task is completed, the device records the time again. This information is sent to a server and stored in a database. The inputs are the user's actions to start and complete the task, and the outputs are the recorded start and completion times.

[1089] Step 7: Handle urgent tasks

[1090] If an urgent task is inserted, the server re-determines the priority including the urgent task. The server updates the task list and presents it to the user again. The input is the urgent task information, and the output is the updated task list.

[1091] Step 8: Adjust task presentation with emotion engine

[1092] The server uses an emotion engine to recognize the user's emotional state. If the user feels anxious, it presents tasks one by one, and if the user feels calm, it presents multiple tasks simultaneously. The input is the user's emotional state, and the output is the adjusted task presentation method.

[1093] (Application example 2)

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

[1095] Conventional task management systems could not take into account the user's status or environment when determining task priorities, making it difficult to complete tasks efficiently. In addition, when an urgent intervening task occurred, tasks had to be reorganized manually, making it difficult to respond quickly. Furthermore, the system lacked the functionality to adjust the way tasks were presented depending on the robot's status, hindering efficient operation of the robot.

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

[1097] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool and preparation for a meeting, a means for determining task priority from past records, a means for organizing tasks based on priority, a means for reorganizing tasks when an urgent insertion task is received, a means for adjusting the method of presenting tasks based on the state of the robot, a means for monitoring the state of the robot, and a means for recording the execution time of tasks. This makes it possible to efficiently determine task priority and present optimal tasks according to the state of the robot.

[1098] A "Communication Tool" is any software or platform that enables users to exchange messages or information between each other.

[1099] A "document review request" is a task to review a specific document or data and request feedback or corrections.

[1100] "Preparing for a meeting" is the task of collecting and organizing the materials and information necessary for the meeting.

[1101] A "task" is a sequence of operations or activities performed to accomplish a particular goal.

[1102] "Past records" are data or information about previously performed tasks and their results.

[1103] "Priority" is an indicator of the importance and urgency of a task.

[1104] "Organization" is the process of efficiently managing tasks and determining the order in which they are to be performed.

[1105] An "urgent inject task" is a task that arises unexpectedly and requires immediate attention.

[1106] "Robot status" is information that indicates the operating status of the robot, such as the remaining battery level and temperature.

[1107] "Task presentation method" refers to how the task is displayed or communicated to the user or robot.

[1108] "Monitoring" is the process of continually checking the status and operation of a robot and responding if necessary.

[1109] "Execution time" is the time it takes from start to finish of a task.

[1110] An embodiment of the present invention will be described.

[1111] The server has a means for receiving tasks such as a request to review documents or preparation for a meeting from the communication tool. This means is realized, for example, by acquiring messages using the Slack API. The server extracts information such as the task content, sender, and sending time from the acquired messages.

[1112] Next, the server has a means for determining the priority of a task from past records. This means uses an algorithm that refers to past task data and evaluates the importance and urgency of the task. For example, the server determines the priority based on data such as how quickly similar tasks were processed in the past and how much resources were required.

[1113] The server further includes a means for sorting tasks based on priority. This means lists tasks in descending order of priority and generates a list to be presented to a user or a robot. When an urgent insertion task is received, the server sorts the tasks again and reevaluates the priorities.

[1114] The server is also equipped with a means for adjusting the way tasks are presented based on the robot's status. This means monitors the robot's operating conditions, such as the remaining battery level and temperature, and changes the way tasks are presented depending on the robot's status. For example, when the robot's battery is low, tasks are presented one at a time, reducing the burden on the robot. On the other hand, when the robot is operating normally, multiple tasks are presented simultaneously, improving productivity.

[1115] The server also includes a means for recording the execution time of a task. This means records the start and end times of a task and reflects the results in the next priority determination. This allows the efficiency of task execution to be continuously improved.

[1116] As a concrete example, consider the case where a task "Assemble part A" is sent from Slack. The server receives this message and determines the priority based on past data. If the robot's battery level is 50% and the temperature is 60 degrees, the server judges the robot's condition to be "normal" and presents multiple tasks simultaneously. The robot performs the presented tasks, and the server records the execution time.

[1117] Example of a prompt to be input to a generative AI model:

[1118] Create a program that receives messages from Slack, determines the priority of tasks, and presents tasks according to the robot's status. The robot's status includes the remaining battery level and temperature. Task priority is determined by referring to past data, and tasks are presented one at a time or multiple at the same time according to the robot's status.

[1119] In this way, the server can efficiently determine task priorities and present optimal tasks according to the robot's state.

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

[1121] Step 1:

[1122] The server receives messages from the communication tool. Specifically, it retrieves messages from a specified channel using the Slack API. The input is the message data from the Slack API, and the output is information such as the message content, sender, and sending time.

[1123] Step 2:

[1124] The server extracts the task contents from the received message. The input is the message data obtained in step 1, and the output is detailed information such as the task contents, sender, and sending time. Specifically, the server analyzes the text part of the message and extracts the parts that are recognized as tasks.

[1125] Step 3:

[1126] The server determines the task priority from past records. The input is the detailed task information extracted in step 2 and past task data, and the output is the task priority. Specifically, the server refers to the past task database and calculates the priority based on data such as how quickly similar tasks were processed and how many resources were required.

[1127] Step 4:

[1128] The server organizes tasks based on priority. The input is the task priority determined in step 3, and the output is a task list organized by priority. Specifically, it lists tasks in descending order of priority and generates a list to present to the user or robot.

[1129] Step 5:

[1130] The server reorganizes tasks when an urgent task is inserted. The input is the newly received urgent task information and the existing task list, and the output is the reorganized task list. Specifically, the priority of the urgent task is immediately evaluated and it is incorporated into the existing task list.

[1131] Step 6:

[1132] The server adjusts the task presentation method based on the robot's status. The input is the robot's status information (battery level, temperature, etc.) and the task list organized in step 4 or step 5, and the output is the adjusted task presentation method. Specifically, it monitors the robot's status, and if the battery is low, it presents tasks one by one, and if the battery is normal, it presents multiple tasks simultaneously.

[1133] Step 7:

[1134] The server records the execution time of a task. The input is the start and end time of the task, and the output is a record of the execution time. Specifically, it records the timestamps when the task is started and when it is completed, calculates the difference between them, and saves the execution time in the database.

[1135] In this way, the server can efficiently determine task priorities and present optimal tasks according to the robot's state.

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

[1137] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ) and other generation AIs. The data generation model 58 is obtained by making a neural network perform deep learning. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating a voice, text data indicating a text, and image data indicating an image is input. The data generation model 58 performs inference on the input inference data according to the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

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

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

[1140] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1153] "Example 1"

[1154] The embodiment of the present invention is a system that cooperates with a communication tool using an API, Webhook, etc., as a means for receiving tasks such as a request to review materials from the communication tool or preparation for a meeting. As a means for determining the priority of a task from past records, the priority is automatically determined using a machine learning algorithm based on information such as the completion time of the past task, the type of task, and the source of the task. As a means for organizing tasks based on priority, tasks are listed in descending order of priority and presented to the user. When an urgent insertion task is received, the tasks are organized again, and the organized tasks are presented to the user. In addition, as a means for recording the execution status of a user's task, the start time, end time, interruption time, etc. of the task are recorded, and the information is reflected in the next priority determination.

[1155] "Example 2"

[1156] As a specific example, consider a system that uses Slack as a communication tool and receives messages from Slack via an API. Based on the task content contained in the message, the time the message was sent, the sender, and other information, the system refers to the completion status of similar tasks in the past and determines the priority of a new task. Tasks are listed in order of highest priority and presented to the user. If an urgent insert task is received, the priority is determined again, including this task, and the task list is updated. When a user starts a task, the time is recorded, and when the task is completed, the time is recorded. This information is reflected in the next priority determination.

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

[1158] "Example 1"

[1159] Step 1: Receive tasks such as document review requests and meeting preparations from communication tools using APIs, Webhooks, etc.

[1160] Step 2: Based on the content of the received task, the time it was sent, the sender, and other information, the completion status of similar tasks in the past is referenced and the priority of the new task is determined.

[1161] Step 3: Present a list of tasks to the user, starting with the highest priority.

[1162] Step 4: If an urgent merge task comes in, reprioritize and update the task list to include that task.

[1163] Step 5: When a user starts a task, record the time, and when the task is completed, record the time. Use this information to inform the next priority decision.

[1164] "Example 2"

[1165] Step 1: Use Slack as a communication tool and receive messages from Slack via the API.

[1166] Step 2: Based on the task content contained in the message, the time the message was sent, the sender, and other information, the completion status of similar tasks in the past is referenced and the priority of the new task is determined.

[1167] Step 3: Present a list of tasks to the user, starting with the highest priority.

[1168] Step 4: If an urgent merge task comes in, reprioritize and update the task list to include that task.

[1169] Step 5: When a user starts a task, record the time, and when the task is completed, record the time. Use this information to inform the next priority decision.

[1170] Example 1

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

[1172] Conventional task management systems have difficulty efficiently receiving tasks from communication tools, properly determining priorities, and presenting them to users. They also lacked the functionality to reorganize tasks when an urgent insertion task occurs, or the functionality to record the user's task completion status and reflect it in the next priority determination. This made task management cumbersome for users and hindered efficient task completion.

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

[1174] In this invention, the server includes a means for receiving tasks from a communication tool, a means for analyzing the contents of the received tasks, a means for collecting past task data, a means for determining task priorities using a machine learning algorithm, a means for organizing tasks based on priorities, a means for reorganizing tasks when an urgent insertion task is received, a means for presenting the organized task list to the user, a means for recording the user's task performance status, and a means for reflecting the recorded performance status in the next priority determination. This makes it possible to consistently perform tasks from receiving them to determining priorities, organizing them, presenting them, and recording their performance status, thereby making the user's task management more efficient.

[1175] A "communication tool" is software or a platform that enables a user to exchange information with other users. Examples include messaging applications and video conferencing systems.

[1176] A "task" is a specific task or activity that a user needs to accomplish. Examples include requesting a document for review or preparing for a meeting.

[1177] A "server" is a computer system that processes data and provides services to other devices over a network.

[1178] "API" stands for Application Program Interface, a set of rules and tools for exchanging data and functions between different software programs.

[1179] A "Webhook" is a mechanism that sends an HTTP request to a specified URL when a specific event occurs.

[1180] A "machine learning algorithm" is a computational method for learning patterns from data and making predictions or classifications. Examples include random forests and support vector machines.

[1181] "Priority" is an indicator of the importance or urgency of a task. A task with a high priority should be completed before other tasks.

[1182] A "task list" is a list of tasks that a user needs to complete, organized according to priority.

[1183] "Performance status" is information that describes how a user is progressing through a task. Examples include the start time, end time, and interruption time of the task.

[1184] A "database" is a system for efficiently storing, searching, and managing data.

[1185] The present invention is a system for efficiently receiving tasks from a communication tool, appropriately determining priorities, and presenting them to a user. A specific embodiment of this system will be described below.

[1186] The server receives tasks from communication tools (e.g. messaging applications and video conferencing systems) using APIs or Webhooks. For example, you can set up a Slack Webhook to get task information when a new message is posted.

[1187] The server analyzes the received task contents using natural language processing (NLP) technology. For example, it extracts keywords such as "review request" or "meeting preparation" from the task title and description.

[1188] The server then collects historical task data from the database, for example using a SQL query to get the completion time and origin of review tasks for the past year.

[1189] The collected past task data is input into a machine learning algorithm (e.g., random forest or support vector machine) to predict the priority of new tasks. For example, the past data is input as features into the model, and a priority score is output.

[1190] The server sorts the tasks based on the priority score and lists them in descending order of priority, i.e., placing tasks with a higher priority score at the top of the list.

[1191] The organized task list is sent from the server to the terminal and presented to the user. The terminal displays the task list to the user and encourages the user to tackle the tasks in order of priority.

[1192] If an urgent injecting task occurs, the server re-organizes the tasks, e.g., when a new urgent task is added, it recalculates the existing task list and sends the updated list to the terminal.

[1193] The time when a user starts, finishes, or stops a task is recorded by the device. For example, when a user presses the "start button" to start a task, the start time is recorded.

[1194] The recorded performance data is sent to the server and reflected in the next priority decision. For example, the task completion time and interruption time are used as training data for the next machine learning model.

[1195] Examples

[1196] Example 1: Requesting a document review

[1197] A user receives a message on Slack saying, "Please review the document." The server receives this message and determines the priority based on the data of past review tasks. If the priority is high, the server notifies the device, "Please give priority to reviewing the document."

[1198] Example 2: Preparing for a meeting

[1199] A user receives a task in Microsoft Teams saying, "Please prepare for tomorrow's meeting." The server receives this task and determines the priority based on the data of past meeting preparation tasks. If the priority is low, the server notifies the device, "Please postpone preparation for the meeting."

[1200] Examples of prompt statements

[1201] "Please prioritize review requests for materials received via Slack. Determine the priority based on the completion time of past review tasks, the type of task, and the source of the task. If the request is high priority, notify the user."

[1202] In this way, we have specifically explained how the server, terminal, and user work together to determine and organize task priorities and present them to the user.

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

[1204] Step 1:

[1205] The server receives tasks from the communication tool using an API or Webhook.

[1206] Input: Task information from communication tools (e.g. Slack messages)

[1207] Output: Received task information

[1208] Specific operation: The server sets up a Slack webhook and receives the contents of a new message when it is posted. For example, it receives a message saying "Please review the document."

[1209] Step 2:

[1210] The server analyzes the contents of the received task.

[1211] Input: Received task information

[1212] Output: Information about the parsed tasks, such as type, origin, and deadline

[1213] Specific operation: The server uses natural language processing (NLP) technology to extract keywords such as "review request" and "meeting preparation" from the task title and description. For example, the server extracts the keyword "review request" from the message "Please review the materials."

[1214] Step 3:

[1215] The server collects past task data from a database.

[1216] Input: Information about the parsed task, such as type, origin, and due date

[1217] Output: Historical task data (e.g. completion time, task type, origin)

[1218] Specific operation: The server uses an SQL query to retrieve the completion time and origin of review tasks from the database over the past year. For example, it collects past task data related to "review requests."

[1219] Step 4:

[1220] The server uses machine learning algorithms to prioritize new tasks based on the past task data it has collected.

[1221] Input: Past task data

[1222] Output: The priority score of the new task.

[1223] Specific operation: The server uses machine learning algorithms such as random forests and support vector machines to input past data as features into a model and output a priority score. For example, it calculates the priority score for a "review request."

[1224] Step 5:

[1225] The server organizes the tasks based on the priority score, listing them in order of priority.

[1226] Input: The priority score of the new task

[1227] Output: An organized task list

[1228] Specific behavior: The server will place tasks with higher priority scores at the top of the list. For example, if "review request" has a high priority score, it will be placed at the top of the list.

[1229] Step 6:

[1230] The server transmits the organized task list to the terminal and presents it to the user.

[1231] Input: An organized task list

[1232] Output: The task list presented to the user.

[1233] Specific operation: The server sends the organized task list to the terminal, and the terminal displays the task list to the user. For example, the user's screen displays "request review" as the top priority task.

[1234] Step 7:

[1235] The server re-arranges tasks if an urgent merge task occurs.

[1236] Input: Urgent mail merge task information

[1237] Output: Updated task list.

[1238] Specific operation: The server recalculates the existing task list when a new urgent task is added and sends the updated list to the terminal. For example, if "urgent meeting preparation" is added, the task list is reorganized.

[1239] Step 8:

[1240] The device records the time when a user starts, finishes, and stops a task.

[1241] Input: User task performance (start time, end time, interruption time)

[1242] Output: Logged performance data

[1243] Specific operation: When a user starts a task, the device records the start time by pressing the "Start" button. Similarly, when the user finishes the task, the device records the end time by pressing the "End" button.

[1244] Step 9:

[1245] The server reflects the recorded performance data in the next priority determination.

[1246] Input: Recorded performance data

[1247] Output: An updated machine learning model.

[1248] Specific operation: The server stores the progress data received from the terminal in a database and uses it as training data for the next machine learning model, for example, to reflect the task completion time and interruption time in the next priority determination.

[1249] (Application example 1)

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

[1251] Conventional factory robots required manual task prioritization, making efficient task management difficult. In addition, when an urgent intervening task occurred, it was difficult to quickly reset task priorities, which could result in work delays and reduced efficiency. Furthermore, there was an insufficient means of recording the task execution status, making it impossible to reflect this in the next task priority determination.

[1252] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means. In this invention, the server includes a means for receiving tasks such as a request for reviewing materials from a communication tool and preparation for a meeting, a means for determining the priority of tasks from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for receiving tasks from a management system or a communication tool in a factory, a means for determining the priority of tasks using a machine learning algorithm based on past task data, a means for listing tasks in order of priority and presenting them to a robot, and a means for recording the start time, end time, interruption time, etc. of a task and reflecting them in the next priority determination. This enables the factory robot to efficiently manage tasks and quickly respond to urgent tasks, thereby preventing work delays and efficiency declines.

[1253] A "communication tool" is software or an application that allows users to exchange information between each other.

[1254] A "material review request" is a request to review and provide feedback on specific documents or data.

[1255] "Preparing for a meeting" refers to the task of gathering the materials and information necessary to ensure the meeting proceeds smoothly.

[1256] A "task" is an operation or activity that must be performed to achieve a particular purpose.

[1257] "Past records" are data about previously performed tasks and their results.

[1258] "Priority" is an indicator of the importance and urgency of a task.

[1259] A "machine learning algorithm" is a computational technique for learning patterns from data and making predictions or classifications.

[1260] "Factory management systems" is a general term for software and hardware used to manage factory operations and production activities.

[1261] The "start time of a task" is the time when the task actually starts.

[1262] "Task end time" is the time when the task is completed.

[1263] A "task suspension time" is a period of time during which a task is temporarily stopped.

[1264] A "robot" is a mechanical device that performs specific tasks automatically.

[1265] "Task progress status" is information that indicates the state or progress of a task.

[1266] A system for carrying out the present invention includes an application installed on a robot used in a factory. A specific embodiment of this system will be described below.

[1267] System Configuration

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

[1269] 1. Communication tools: Software or applications that allow users to exchange information between each other.

[1270] 2. Factory management systems: Software and hardware for managing factory operations and production activities.

[1271] 3. Robot: A mechanical device used to perform specific tasks automatically.

[1272] 4. Server: A central processing unit for receiving tasks, determining priorities, organizing tasks, and recording their execution status.

[1273] Program Processing

[1274] The server processes the data in the following steps:

[1275] 1. Receiving a task:

[1276] The server receives tasks from the factory's management system and communication tools, and the tasks to be executed by the robots are then consolidated on the server.

[1277] 2. Prioritization:

[1278] The server uses a machine learning algorithm to determine task priorities based on past task data. Specifically, it uses information such as past task completion times, task types, and origins as input data and predicts priorities using a generative AI model.

[1279] 3. Organize your tasks:

[1280] The server lists tasks in order of priority and presents them to the robot, allowing the robot to complete the tasks efficiently.

[1281] 4. Recording task completion status:

[1282] The server records the start time, end time, interruption time, etc. of the task and reflects this in the next priority determination, thereby improving the accuracy of task management.

[1283] Hardware and Software Used

[1284] Hardware: Factory robots, servers

[1285] Software: Python, scikit-learn (machine learning library), requests (HTTP request library)

[1286] Examples

[1287] For example, if a robot in a factory receives an "assembly task" and an "inspection task," past data will determine that the "assembly task" has a higher priority. The robot will carry out the "assembly task" first, and then the "inspection task." In this way, the robot can efficiently manage tasks and quickly respond to emergency tasks.

[1288] Examples of prompt statements

[1289] Design a system that automatically prioritizes tasks received by robots in factories and allows them to complete tasks efficiently. Use a machine learning algorithm to determine priorities based on past task data, and give the system the ability to list tasks in order of priority and present them to the robots. Also, add a function to record the task completion status and reflect it in the next priority determination.

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

[1291] Step 1:

[1292] The server receives tasks from the management system and communication tools in the factory. Specifically, it obtains task data from the API using an HTTP request. The input includes detailed task information (task ID, task content, origin, etc.). The output is that the received task data is stored in the server.

[1293] Step 2:

[1294] The server uses a machine learning algorithm to determine task priorities based on past task data. Specifically, it uses information such as past task completion times, task types, and origins as input data and predicts priorities using a generative AI model. The inputs include past task data and new task data. The output is the priority of each task.

[1295] Step 3:

[1296] The server lists tasks in descending order of priority and presents them to the robot. Specifically, the server sorts the tasks in descending order of priority and sends them to the robot in list form. The input includes task data with the determined priorities. The output is the sorted task list presented to the robot.

[1297] Step 4:

[1298] The robot performs tasks based on the presented task list. Specifically, it executes the tasks from the top of the list and records the start and end times of the tasks. The input includes a sorted task list. The output records the execution results of the performed tasks and their timestamps.

[1299] Step 5:

[1300] The server records the task execution status and reflects it in the next priority decision. Specifically, the start time, end time, interruption time, etc. of the task are stored in a database and used as training data for the next machine learning model. The input includes the execution result and timestamp of the completed task. The output is an updated task database.

[1301] Example 2

[1302] Next, a second embodiment of the second form will be described. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal".

[1303] In conventional task management systems, it was difficult to properly determine the priority of tasks received from communication means and to reorganize tasks when an urgent insertion task occurred. In addition, there was a lack of functionality to record the user's task execution status and reflect it in the next priority determination, making it impossible to achieve efficient task management.

[1304] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving a task from a communication means, a means for saving information on the received task, a means for determining the priority of the task from past records, a means for organizing the tasks based on the priority, a means for reorganizing the tasks when an urgent insertion task is received, a means for recording the start time and completion time of the user's task, and a means for reflecting the recorded information in the next priority determination. This makes it possible to appropriately determine the priority of the task, quickly respond to an emergency task, and efficiently manage tasks reflecting the user's performance status.

[1305] A "communication means" is a device or system for sending and receiving information via a network.

[1306] A "task" is an operation or activity that must be performed to achieve a particular goal.

[1307] A "receiving means" is a function or process for obtaining information sent from a communication means.

[1308] "Means of storage" refers to the functions or processes for recording received information in a database or storage.

[1309] "Past records" refers to previously saved task status and related information.

[1310] A "prioritization method" is a function or process for evaluating and ranking the importance and urgency of tasks.

[1311] "Organizing tools" are functions or processes that sort tasks based on determined priorities and make them more manageable.

[1312] An "urgent in-place task" is a task that arises unexpectedly and requires immediate attention.

[1313] A "means for re-ordering tasks" is a function or process for re-evaluating and re-ordering the priority of existing tasks when an urgent insert task arises.

[1314] "Start time" is the time when the user begins the task.

[1315] "Completion Time" is the time when a user completes a task.

[1316] A "means for recording" is a function or process for recording the start time and completion time of a task in a database or storage.

[1317] "Means for reflecting in next priority determination" refers to a function or process for more accurately evaluating the priority of the next task based on the recorded information.

[1318] A "generative AI model" is a model that uses artificial intelligence to analyze data and is trained to perform a specific task.

[1319] This invention relates to a task management system that can appropriately determine the priority of tasks received from communication means and can quickly respond to urgent tasks. Furthermore, it records the task execution status of users and reflects it in the next priority determination, thereby realizing efficient task management.

[1320] Hardware and Software Used

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

[1322] Software: communication tools (e.g. messaging applications), communication APIs, databases (e.g. MySQL), generative AI models (e.g. GPT-4)

[1323] System Overview

[1324] 1. Receiving a Message

[1325] The server receives the task sent from the communication means using the communication means API.

[1326] For example, the server may receive a task to "create a proposal for a new project."

[1327] 2. Data storage

[1328] The server stores the received task contents, sending time, and sender information in a database.

[1329] For example, the task content “Create a proposal for a new project”, the sending time “2023-10-01 10:00:00”, and the sender “user123” are saved.

[1330] 3. Reference to past data

[1331] The server refers to a database for past execution status of similar tasks.

[1332] For example, it is referenced that the completion time of the past "Write proposal" task was "2023-09-25 15:00:00".

[1333] 4. Determining Priorities

[1334] The server uses a generative AI model (e.g. GPT-4) to prioritize new tasks.

[1335] For example, an AI model may rate the task "Create a proposal for a new project" as a "high" priority.

[1336] 5. Creating a task list

[1337] The server creates a task list by listing tasks in descending order of priority.

[1338] For example, on your task list you might write "1. Create a proposal for new project" and "2. Prepare for client meeting."

[1339] 6. Dealing with Urgent Tasks

[1340] If an urgent insertion task is received, the server will re-determine the priority including that task.

[1341] For example, if an urgent task such as "responding to a sudden inquiry from a client" comes in, the task list is updated.

[1342] 7. Recording when tasks are started and completed

[1343] When a user starts a task, the time is recorded from the device.

[1344] For example, if a user starts a task "Create a proposal for a new project" at 10:30 and completes it at 12:00, record that time.

[1345] 8. Reflection in the next priority decision

[1346] The server will use the recorded task start and completion times to determine the next priority.

[1347] For example, it can learn that past "proposal writing" tasks took an average of two hours and reflect that in determining the next priority.

[1348] Examples of prompt statements

[1349] "Please explain a system that determines the priority of tasks and generates a task list based on messages received from a communication means. Please explain the specific process flow and the hardware and software used."

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

[1351] Step 1:

[1352] Receiving messages

[1353] The server receives the task sent from the communication means using the communication means API.

[1354] Input: Message data from the communication medium (e.g. task content, sending time, sender)

[1355] Output: Received message data

[1356] What happens: The server sets up a communication API and listens for messages from a specific channel or user, for example, to receive a message saying "Create a proposal for a new project."

[1357] Step 2:

[1358] Data storage

[1359] The server stores information about the received message, including the content, time of sending, and sender in a database.

[1360] Input: Received message data

[1361] Output: Task information stored in a database

[1362] Specific operation: The server executes an INSERT statement in a database such as MySQL to save the data. For example, it saves the task content "Create a proposal for a new project", the sending time "2023-10-01 10:00:00", and the sender "user123".

[1363] Step 3:

[1364] View past data

[1365] The server refers to a database for past execution status of similar tasks.

[1366] Input: Past task data in the database

[1367] Output: Referenced past task data

[1368] Specific operation: The server executes a SELECT statement to obtain the completion time and priority of past "Write proposal" tasks. For example, it references that the completion time of the past "Write proposal" task was "2023-09-25 15:00:00".

[1369] Step 4:

[1370] Determining Priorities

[1371] The server uses a generative AI model (e.g. GPT-4) to prioritize new tasks.

[1372] Input: Referenced previous task data, new task data

[1373] Output: Determined task priority

[1374] How it works: The server inputs past data into the AI ​​model and evaluates the urgency and importance of the task. For example, the AI ​​model evaluates the task "Create a proposal for a new project" as a "high" priority.

[1375] Step 5:

[1376] Generate a task list

[1377] The server creates a task list by listing tasks in descending order of priority.

[1378] Input: Determined task priority

[1379] Output: task list

[1380] What it does: The server sorts the tasks based on priority and stores them in a database in list format. For example, a task list might read "1. Create a proposal for a new project" and "2. Prepare for a client meeting."

[1381] Step 6:

[1382] Urgent task response

[1383] If an urgent insertion task is received, the server will re-determine the priority including that task.

[1384] Input: New urgent task data, existing task list

[1385] Output: Updated task list

[1386] Specific operation: The server inputs new tasks into the AI ​​model and reevaluates the overall priority. For example, if an urgent task such as "responding to an urgent inquiry from a client" is received, the task list is updated.

[1387] Step 7:

[1388] Recording task initiation and completion

[1389] When a user starts a task, the time is recorded from the device.

[1390] Input: Task start time, completion time

[1391] Output: Recorded task start and completion times

[1392] Specific operation: The user presses the "Start" button through the terminal interface, and the server saves the time in the database. When the task is completed, the user presses the "Finish" button in the same way, and the completion time is recorded. For example, if the user starts the task "Write a proposal for a new project" at 10:30 and completes it at 12:00, the time will be recorded.

[1393] Step 8:

[1394] Reflection in next priority decision

[1395] The server will use the recorded task start and completion times to determine the next priority.

[1396] Input: Recorded task start and completion times

[1397] Output: Data reflected in the next priority decision

[1398] How it works: The server inputs past execution times and completion status into the AI ​​model to more accurately evaluate the next task priority. For example, it learns that past "proposal writing" tasks took an average of two hours, and reflects this in determining the next priority.

[1399] (Application example 2)

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

[1401] In conventional task management systems, it was difficult to properly determine the priorities of complex tasks in a factory and to manage them efficiently. In addition, when an urgent task occurred, it was not possible to quickly update the task list and reset the appropriate priority. Furthermore, there was a lack of a mechanism to record the task execution status and reflect it in the next priority determination, which led to a problem of reduced overall work efficiency.

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

[1403] In this invention, the server includes a means for receiving tasks such as a request for reviewing materials from a communication tool or preparation for a meeting, a means for determining the priority of tasks from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for receiving task information from a management system in a factory, a means for analyzing information such as the content of a task, the sending time, and the sender, a means for recording the task start time and completion time, a means for determining the priority of a task using a generative AI model, and a means for generating a prompt sentence. This makes it possible to appropriately determine the priority of complex tasks in a factory and efficiently manage them. Furthermore, even if an urgent insertion task occurs, the task list can be quickly updated and the priority can be reset appropriately. In addition, by recording the progress of the tasks and reflecting it in the next priority determination, the overall work efficiency can be improved.

[1404] A "communication tool" is software or a platform that allows users to exchange messages or information between each other.

[1405] A "material review request" is a request to review specific documents or data and seek feedback or corrections.

[1406] "Preparing for a meeting" refers to the task of collecting and organizing the materials and information necessary to ensure the smooth running of the meeting.

[1407] A "task" is a unit of work or activity that must be performed to achieve a specific purpose.

[1408] "Past records" are data showing the progress and results of tasks previously performed.

[1409] "Priority" is an index of importance that indicates which of multiple tasks should be performed first.

[1410] "Organizing" is the act of classifying and arranging tasks based on certain criteria.

[1411] An "urgent inject task" is a task or activity that arises unexpectedly and requires immediate attention.

[1412] "Factory management systems" is a general term for software and hardware used to oversee and manage a factory's production activities and operations.

[1413] "Task information" is detailed data such as the task content, sending time, sender, and so on.

[1414] "Analysis" is the process of examining data or information in detail to clarify its meaning and structure.

[1415] "Task start time" is the time when a particular task actually begins.

[1416] "Task completion time" is the time when a particular task is actually completed.

[1417] A "generative AI model" is an algorithm or program that uses artificial intelligence technology to analyze data and generate new information or results.

[1418] A "prompt" is an instruction or question to be input into a generative AI model.

[1419] A system for carrying out the present invention is for linking with a management system within a factory, appropriately determining the priority of tasks, and efficiently managing them. A specific embodiment of the system will be described below.

[1420] System Configuration

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

[1422] 1. Server: Plays a central role in receiving task information, analyzing it, and determining priorities.

[1423] 2. Factory management system: A system that provides task information, such as an MES system.

[1424] 3. Generative AI Model: An artificial intelligence model used to prioritize tasks.

[1425] 4. User terminal: A device that displays the task list and allows the user to manage the progress of tasks.

[1426] Program Processing

[1427] The server receives task information from the factory's management system. The task information includes detailed data such as the task content, transmission time, and sender. The server analyzes this information and determines the priority of the task based on past records. A generative AI model is used to determine the priority.

[1428] The server organizes tasks based on priority and presents a task list to the user terminal. If an urgent insertion task occurs, the server determines the priority again and updates the task list. It records the time when the user starts and completes the task, and reflects this in the next priority determination.

[1429] Hardware and Software Used

[1430] Hardware: Factory robots (e.g. KUKA, Fanuc, etc.), user terminals (e.g. PCs, tablets)

[1431] Software: Python, API communication library (requests), generative AI model

[1432] Examples

[1433] For example, when a new task is sent from the management system in a factory, the server receives the task, determines its priority, and updates the task list. If an urgent maintenance task is received, the server gives priority to the task.

[1434] Examples of prompt statements

[1435] An example of a prompt to be input to the generative AI model is as follows:

[1436] A new task has been sent from the factory management system. The task content is "Maintenance of Machine A", the sending time is "2023-10-01T10:00:00", and the sender is "Administrator". Please determine the priority of this task and update the task list.

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

[1438] Step 1:

[1439] The server receives task information from the management system in the factory. The input is the task information sent from the management system, and the output is the received task information data. In concrete terms, the server obtains the task information through the API and stores details such as the task content, sending time, and sender in the database.

[1440] Step 2:

[1441] The server analyzes the received task information. The input is the task information received in step 1, and the output is the analyzed task details. In concrete terms, the server extracts information such as the task content, sending time, sender, etc., and stores these data in individual variables.

[1442] Step 3:

[1443] The server determines the priority of a task based on past records. The input is the analyzed task details and past task records, and the output is the determined task priority. In concrete terms, the server uses a generative AI model to refer to past task execution status and calculate the priority of the current task.

[1444] Step 4:

[1445] The server organizes tasks based on priority. The input is the determined task priority, and the output is the organized task list. In concrete terms, the server generates a task list according to the task priority and sorts the tasks by priority.

[1446] Step 5:

[1447] The server presents the organized task list to the user terminal. The input is the organized task list, and the output is the task list displayed on the user terminal. In specific operation, the server transmits the task list to the user terminal for the user to view.

[1448] Step 6:

[1449] When an urgent insertion task occurs, the server re-determines the priority and updates the task list. The input is the urgent insertion task information, and the output is the updated task list. In concrete terms, the server analyzes the newly received urgent task, re-determines the priority using the generative AI model, and updates the task list.

[1450] Step 7:

[1451] The user records the time when the task is started and completed. The input is the task information that the user reports as started and completed, and the output is the recorded task start and completion times. In concrete terms, the user presses a button when the task is started, and also presses a button when the task is completed, and the start and completion times are sent to the server.

[1452] Step 8:

[1453] The server reflects the recorded task performance status in the next priority determination. The input is the recorded task start time and completion time, and the output is the data to be used in the next priority determination. In concrete terms, the server stores the task performance time in a database and refers to this data when determining the next task priority.

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

[1455] "Example 1"

[1456] One embodiment of the present invention is a task management system incorporating an emotion engine. This system recognizes the emotions of a user and adjusts task priorities based on the user's emotional state. Specifically, if the emotion engine recognizes that the user is feeling stressed, it increases the priority of tasks that have the potential to reduce the stress. In addition, if the emotion engine recognizes that the user is relaxed, it increases the priority of tasks that require concentration. This allows the user to perform optimal tasks according to their emotional state.

[1457] "Example 2"

[1458] In another embodiment of the present invention, there is a system in which an emotion engine adjusts the way in which tasks are presented based on the emotional state of the user. Specifically, if the emotion engine recognizes that the user is feeling impatient, it presents tasks one by one, thereby reducing the burden on the user. On the other hand, if the emotion engine recognizes that the user is calm, it presents multiple tasks simultaneously, thereby improving the user's productivity. This makes it possible to present optimal tasks according to the user's emotional state.

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

[1460] "Example 1"

[1461] Step 1: The emotion engine recognizes the user's emotional state.

[1462] Step 2: Adjust the priority of tasks based on the emotional state recognized by the emotion engine. For example, if it recognizes that the user is feeling stressed, it will increase the priority of tasks that may reduce stress.

[1463] Step 3: Present tasks to users based on the adjusted priorities.

[1464] "Example 2"

[1465] Step 1: The emotion engine recognizes the user's emotional state.

[1466] Step 2: Based on the emotional state recognized by the emotion engine, adjust the way tasks are presented. For example, if it recognizes that the user is feeling impatient, present the tasks one by one. Step 3: Based on the adjusted presentation method, present the tasks to the user.

[1467] Example 1

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

[1469] Conventional task management systems cannot take into account the user's emotional state when determining task priorities, making it difficult to optimally manage tasks according to the user's stress and concentration. In addition, there are problems such as not being able to quickly reorganize tasks when an urgent insert task occurs, and lacking a function to record the user's task execution status and reflect it in the next priority determination.

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

[1471] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool or preparations for a meeting, a means for determining task priority from past records, a means for organizing tasks based on priority, a means for reorganizing tasks when an urgent insertion task is received, a means for recognizing the emotional state of a user and adjusting task priority based on the emotional state, a means for recording the start time, end time, interruption time, etc. of a user's task, and a means for presenting the organized tasks to the user. This enables optimal task management according to the emotional state of the user, and realizes rapid reorganization of urgent tasks, recording of task execution status, and reflection of the status in the next priority determination.

[1472] "Communication Tools" means software or platforms that Users use to exchange information with other Users.

[1473] A "task" refers to a specific task or activity that a user needs to accomplish.

[1474] "Priority" is an index of importance that indicates which task among multiple tasks should be performed first.

[1475] "Emotional state" refers to the user's psychological state and includes emotions such as stress or relaxation.

[1476] An "emotion engine" is an algorithm or software for recognizing a user's emotional state and adjusting the system's behavior based on that state.

[1477] "Task completion status" refers to information such as the time when a user started a task, the time when the user finished the task, and the time when the user stopped the task.

[1478] An "urgent inject task" is a high-priority task that is unexpectedly added to an existing task list.

[1479] A "database" is a system for storing information such as past task data and user performance status.

[1480] A "machine learning algorithm" is an algorithm that learns patterns based on past data and makes predictions and classifications for new data.

[1481] An "API" is an interface that allows different software systems to communicate with each other.

[1482] A "Webhook" is a mechanism that sends an HTTP request to a specified URL when a specific event occurs.

[1483] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[1484] This invention is a system that receives tasks from a communication tool, determines the priority of the tasks based on past records and the emotional state of the user, and presents the organized tasks to the user. A specific embodiment of this system will be described below.

[1485] Receiving tasks from communication tools

[1486] The server receives tasks from communication tools (e.g. Slack, Microsoft Teams) using APIs or Webhooks. For example, by setting up a Slack Webhook, when a new message is posted in a specific channel, the server receives the content.

[1487] Parsing task information

[1488] The server parses the received message and extracts details such as task type, origin, deadline, etc. For example, when a message is posted saying "Please prepare for a meeting," the server extracts the task type "prepare for a meeting" and the origin "Slack."

[1489] Get past task data

[1490] The server retrieves information from the database about past task completion times, task types, origins, etc. For example, it checks how long similar tasks took to complete in the past.

[1491] Task Prioritization

[1492] The server uses machine learning algorithms (e.g., random forests, support vector machines) to prioritize new tasks based on past task data. For example, tasks that took a long time in the past are set to a higher priority.

[1493] Organizing and listing tasks

[1494] The server will organize the tasks based on priority and list them in order of priority, for example the "prepare for meeting" task will be at the top of the list as it has the highest priority.

[1495] Present tasks to users

[1496] The terminal presents the user with an organized task list. For example, the user's PC screen shows "Prepare for a meeting" as the top priority task.

[1497] Handling urgent tasks

[1498] If an urgent merge task occurs, the server reorganizes the tasks and sends the updated list to the terminal. For example, if an "urgent bug fix" occurs, that task is displayed at the top of the list as the highest priority.

[1499] Recording task completion status

[1500] The server records the start time, end time, interruption time, etc. of a user's task. For example, the server records the time when a "prepare for meeting" task was started and ended.

[1501] Prioritization using emotion engine

[1502] The server uses an emotion engine to recognize the user's emotional state and adjusts task priorities based on that state. For example, if the user is feeling stressed, it will increase the priority of the "reading materials" task, which is relaxing.

[1503] Examples of concrete examples and prompts

[1504] Examples

[1505] When a user uses Slack, a "prepare for a meeting" task is sent to the server via Slack's webhook. The server determines the priority based on the data of past meeting preparation tasks and lists them as high-priority tasks. If the emotion engine recognizes that the user is feeling stressed, it sets the "reading materials" task, which is relaxing, as a high priority.

[1506] Examples of prompt statements

[1507] "Try to prioritize meeting preparation tasks you receive from Slack, and if users are feeling stressed, prioritize tasks that will help them relax."

[1508] In this way, by explaining the system processing from the perspectives of the server, terminal, and user, the specific operations and technologies used become clear.

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

[1510] Step 1:

[1511] The server receives tasks from the communication tool using an API or Webhook.

[1512] Input: Task information from communication tools (e.g. Slack messages)

[1513] Output: Received task information

[1514] Specific operation: The server sets up a Slack webhook and receives the contents of a new message posted in a specific channel. For example, when a message "Please prepare for a meeting" is posted, the contents are sent to the server.

[1515] Step 2:

[1516] The server parses the received task information and extracts details such as the task type, origin, and deadline.

[1517] Input: Received task information

[1518] Output: Detailed information about the parsed tasks (task type, origin, deadline, etc.)

[1519] Specific operation: The server analyzes the received message, extracts the task type "prepare for meeting" and the source "Slack", and identifies the deadline from the date information included in the message.

[1520] Step 3:

[1521] The server retrieves information such as past task completion times, task types, and origins from the database.

[1522] Input: Task details

[1523] Output: Past task data

[1524] What happens: The server queries the database to get past completion times for "prepare for meeting" tasks and tasks originating from "Slack." For example, it checks how long similar tasks took to complete in the past.

[1525] Step 4:

[1526] The server uses machine learning algorithms to determine the priority of new tasks based on the past task data it has acquired.

[1527] Input: Past task data, detailed task information

[1528] Output: Determined task priority

[1529] How it works: The server uses a random forest algorithm to analyze past task data and determine the priority of new tasks. For example, tasks that took a long time in the past are set to a higher priority.

[1530] Step 5:

[1531] The server organizes tasks based on priority, listing them in descending order of priority.

[1532] Input: Determined task priority

[1533] Output: An organized task list

[1534] What happens: The server sorts the tasks based on priority and lists them in order of priority. For example, the "Prepare for meeting" task is the top priority and appears at the top of the list.

[1535] Step 6:

[1536] The terminal presents the user with an organized task list.

[1537] Input: An organized task list

[1538] Output: The task list presented to the user.

[1539] Specific operation: The terminal displays an organized task list on the user's PC screen. For example, "Prepare for meeting" is displayed as the top priority task.

[1540] Step 7:

[1541] If an urgent insertion task occurs, the server reorganizes the tasks and transmits an updated list to the terminal.

[1542] Input: Urgent mail merge task information

[1543] Output: Updated task list.

[1544] What it does: If an urgent merge task occurs, the server adds it to the list and sorts the tasks again based on priority. For example, if an "urgent bug fix" occurs, that task will be displayed at the top of the list as the highest priority.

[1545] Step 8:

[1546] The server records the start time, end time, interruption time, etc. of a user's task.

[1547] Input: User's task performance status

[1548] Output: Recorded task performance data

[1549] Specific operation: The server records the time when the user starts, finishes, and stops a task. For example, it records the time when the "prepare for meeting" task starts and ends.

[1550] Step 9:

[1551] The server uses an emotion engine to recognize the user's emotional state and adjusts task priorities based on that state.

[1552] Input: The user's emotional state

[1553] Output: Adjusted task priorities

[1554] Specific operation: The server uses the emotion engine to analyze the user's emotional state, and if the user is feeling stressed, it increases the priority of tasks that help the user relax. For example, if the server recognizes that the user is feeling stressed, it increases the priority of the "reading materials" task.

[1555] (Application example 1)

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

[1557] In conventional task management systems, the user's emotional state or the robot's operating status could not be taken into account when determining task priorities, making it difficult to carry out tasks efficiently. In addition, when an urgent intervening task occurs, tasks are often not reorganized promptly, resulting in a decrease in work efficiency.

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

[1559] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool and preparations for a meeting, a means for determining task priority from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for determining task priority using a machine learning algorithm, a means for adjusting task priority based on the emotional state of a user using an emotion engine, and a means for recognizing the state of the robot based on data from the robot's sensor and adjusting task priority. This enables efficient task management that takes into account the emotional state of the user and the operating status of the robot.

[1560] A "communication tool" is software or a platform that allows users to exchange information.

[1561] A "request for document review" is a task to check the contents of a specific document or data and ask for opinions or corrections.

[1562] "Preparing for a meeting" is the task of preparing the materials and information necessary to ensure the meeting proceeds smoothly.

[1563] A "task" is an operation or activity that must be performed to achieve a particular purpose.

[1564] "Past records" are data about previously performed tasks and their results.

[1565] "Priority" is an indicator of the importance and urgency of a task.

[1566] A "machine learning algorithm" is a computational technique that learns patterns from data and makes predictions and classifications.

[1567] An "emotion engine" is a technology for recognizing a user's emotional state and adjusting the system's behavior based on that.

[1568] A "robot" is a mechanical device that performs tasks automatically.

[1569] A "sensor" is a device that detects information about the physical environment and outputs it as data.

[1570] "Adjusting task priorities" means reevaluating the importance and urgency of tasks and changing the order of execution.

[1571] "Task organization" means classifying and ordering tasks in order to manage them efficiently.

[1572] An "urgent inject task" is a task that occurs unscheduled and requires immediate attention.

[1573] The system for carrying out the present invention is configured as follows: The server has a means for receiving tasks such as requests to review materials and preparations for meetings from communication tools, allowing the user to obtain tasks directly from the communication tool he or she is using.

[1574] Next, the server has a means to determine the priority of tasks from past records. Priorities are automatically determined using a machine learning algorithm based on information such as past task completion times, task types, and origins. For this machine learning algorithm, for example, scikit-learn's RandomForestClassifier is used.

[1575] In addition, the server has a means to organize tasks based on priority. It lists tasks in descending order of priority and presents them to the user. When an urgent task is inserted, it organizes the tasks again and presents the organized tasks to the user.

[1576] The server also has a means for adjusting task priorities based on the user's emotional state using an emotion engine. If the server recognizes that the user is stressed, the emotion engine increases the priority of tasks that may reduce the stress. If the server recognizes that the user is relaxed, the emotion engine increases the priority of tasks that require concentration. The emotion engine recognizes the user's emotional state based on data from sensors, for example.

[1577] In addition, the server has a means to recognize the robot's status based on data from the robot's sensors and adjust task priorities. Based on data from the robot's temperature and vibration sensors, the server recognizes the robot's "status" and adjusts task priorities.

[1578] As a concrete example, consider the following cases where tasks occur in a factory: Task 1 is assembly work, has a completion time of 30 minutes, and originates from Line 1. Task 2 is inspection work, has a completion time of 20 minutes, and originates from Line 2. If the robot's sensors recognize a "relaxed" state, the priority of tasks that require concentration (e.g., inspection work) will increase.

[1579] An example of a prompt sentence might be:

[1580] "Please generate a Python program that recognizes the robot's status and adjusts task priorities based on data from the factory robot's sensors. Please include a function that uses a machine learning algorithm to determine priorities based on data such as the type of task and completion time, and adjusts priorities using an emotion engine."

[1581] In this way, efficient task management is possible, taking into account the user's emotional state and the robot's operating status.

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

[1583] Step 1:

[1584] The server receives tasks such as document review requests and preparations for meetings from the communication tools. As input, it receives task information (task name, completion time, origin, etc.) from the communication tools and stores it in an internal database. As output, the received task information is stored in the database.

[1585] Step 2:

[1586] The server determines the priority of tasks from past records. As input, past task data (completion time, task type, origin, etc.) is input to a machine learning algorithm. As data processing, this data is extracted as features, and the priority is predicted using a machine learning model (e.g., Random Forest Classifier). As output, the priority of each task is determined.

[1587] Step 3:

[1588] The server organizes tasks based on priority. As input, it receives the prioritized task list determined in step 2. As data operation, it sorts the tasks in descending order of priority. As output, it produces the organized task list.

[1589] Step 4:

[1590] The server re-orders tasks when an urgent injecting task is received. As input, it takes the newly received urgent task information and adds it to the existing task list. As data operation, it re-evaluates the priority of all tasks and re-sorts them. As output, it generates an updated task list.

[1591] Step 5:

[1592] The server uses an emotion engine to adjust task priorities based on the user's emotional state. As input, it receives the user's emotional state data (e.g., stress level and relaxation level from sensors). As data processing, it adjusts the priority of certain tasks according to the emotional state. As output, a task list reflecting the emotional state is generated.

[1593] Step 6:

[1594] The server recognizes the robot's status based on data from the robot's sensors and adjusts task priorities. As input, it receives the robot's sensor data (temperature, vibration, etc.). As data processing, it analyzes this data and recognizes the robot's status. As data calculation, it readjusts task priorities according to the robot's status. As output, it generates a task list that reflects the robot's status.

[1595] Step 7:

[1596] The server presents the organized tasks to the user. As input, it receives the final organized task list. As a concrete operation, it displays the task list through a user interface. As output, it presents the task list in a form that the user can view.

[1597] Step 8:

[1598] The server records the user's task execution status. As input, it receives timestamp data when the user starts, finishes, and interrupts a task. As data processing, it records this data and reflects it in the next priority decision. As output, the execution status is stored in a database.

[1599] Example 2

[1600] Next, a second embodiment of the second form will be described. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal".

[1601] In conventional task management systems, it is difficult to properly determine the priority of tasks, and there is a lack of means to reorganize tasks when an urgent task is inserted. In addition, the method of presenting tasks according to the user's emotional state is not taken into consideration, which increases the burden on the user and reduces productivity.

[1602] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving a task from a communication tool, a means for analyzing the content, transmission time, and sender of the received task, a means for acquiring past task data, a means for calculating the priority of a new task based on the past task data, a means for organizing tasks based on the priority, a means for presenting the organized tasks to the user, a means for recording the start and completion of the user's tasks, a means for reorganizing tasks when an urgent insertion task is received, and a means for adjusting the method of presenting tasks based on the user's emotional state. This makes it possible to appropriately determine the priority of tasks and quickly reorganize tasks even when an urgent task is received. In addition, by adjusting the method of presenting tasks according to the user's emotional state, it becomes possible to reduce the burden on the user and improve productivity.

[1603] A "Communication Tool" is any software or platform that enables users to exchange messages or information between each other.

[1604] A "task" is a specific task or activity that a user must complete.

[1605] "Means of receiving" refers to the functions and methods for obtaining information or data from outside.

[1606] "Means of analysis" refers to the functions and methods for understanding received information or data and extracting the necessary elements.

[1607] "Past Task Data" means information or records relating to tasks previously performed.

[1608] "Means of acquisition" refers to the functions or methods for collecting specific information or data.

[1609] A "means for calculating priority" is a function or method for evaluating the importance and urgency of tasks and determining their order.

[1610] An "organizing means" is a function or method for arranging tasks in a sequence based on specific criteria.

[1611] A "means of presentation" is a function or method for displaying information or data to a user.

[1612] A "means of recording" is a function or method for storing specific information or data.

[1613] An "urgent in-place task" is a task that arises suddenly and requires a quick response.

[1614] "Emotional state" refers to a user's psychological state or mood.

[1615] An "adjustment means" is a function or method for changing a method or setting based on certain conditions.

[1616] This invention is a system that receives tasks from a communication tool, calculates priorities based on past task data, and presents them to the user. It also has a function to adjust the way tasks are presented depending on the user's emotional state.

[1617] Hardware and Software Used

[1618] The server uses the following hardware and software to realize the system:

[1619] Hardware: Servers, terminals (users' PCs and smartphones)

[1620] Software: Python, Slack API, natural language processing libraries (e.g. spaCy), databases (e.g. MySQL), machine learning libraries (e.g. scikit-learn), web application frameworks (e.g. Flask)

[1621] Program Processing

[1622] The server receives messages from Slack using the Slack API. It uses a natural language processing library to analyze the content, sent time, and sender of the received messages. Based on the analyzed information, it retrieves past task data from the database. It uses a machine learning model to calculate the priority of new tasks based on the past task data.

[1623] Tasks with calculated priorities are organized based on their priority and presented to the user's browser using a web application framework. When the user starts a task, the device records the time and again when the task is completed. This information is sent to the server and stored in a database.

[1624] If an urgent task is inserted, the server reprioritizes the task list, including the task, and updates the task list. In addition, the server uses an emotion engine to recognize the user's emotional state, and presents tasks one at a time if the user is feeling impatient, and presents multiple tasks simultaneously if the user is calm.

[1625] Examples

[1626] As a concrete example, consider a case where a user receives a message in Slack saying "Please create documentation for a new project." This message is sent to the server, which processes it as follows:

[1627] 1. The server receives the message via the Slack API.

[1628] 2. Extract the message content “Create materials for a new project”, the sent time, and the sender.

[1629] 3. Obtain past task data related to "Document creation" from the database. For example, confirm that the average time required for "Document creation" is 2 hours.

[1630] 4. The server calculates the priority of the new task “Document Creation” based on past data. For example, it is determined to be high in importance and high in urgency.

[1631] 5. The server places the high priority task "Document Creation" at the top of the list and displays it in the user's browser.

[1632] 6. When the user starts "creating a document", the device records the start time. When the task is completed, the device records the completion time.

[1633] 7. If an urgent task called "Prepare for emergency meeting" is added, the server recalculates the priority to include that task and updates the task list.

[1634] 8. If the server uses the emotion engine to determine that the user is feeling anxious, it presents the "Create materials" task one by one. If the server determines that the user is calm, it presents the "Create materials" and "Prepare for an emergency meeting" tasks simultaneously.

[1635] Examples of prompt statements

[1636] If you receive a message in Slack saying, "Please create materials for a new project," calculate the priority of this task and present it to the user in a list with other tasks.

[1637]

[1638] If the user is feeling rushed, present them with one task at a time. If the user is calm, present them with multiple tasks at once.

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

[1640] Step 1: Receiving a message

[1641] The server receives messages from Slack using the Slack API. Specifically, it uses the Slack event API to obtain messages sent from specific channels and users in real time. The input is a message from Slack, and the output is the received message data.

[1642] Step 2: Parsing the message

[1643] The server analyzes the content, sending time, and sender of received messages. It uses a natural language processing library (e.g., spaCy) to extract task content from the message text. The input is the received message data, and the output is the analyzed task content, sending time, and sender information.

[1644] Step 3: Retrieve past task data

[1645] The server retrieves past task data from a database (e.g. MySQL). Specifically, it queries how similar tasks have been performed in the past, their duration and completion status. The input is the parsed task content, and the output is the past task data.

[1646] Step 4: Task Priority Calculation

[1647] The server calculates the priority of new tasks based on past task data. It uses a machine learning model (e.g., scikit-learn) to evaluate the importance and urgency of tasks. The input is the past task data, and the output is the calculated task priority.

[1648] Step 5: Generate and present the task list

[1649] The server lists tasks in order of priority and presents them to the user. A web application framework (e.g. Flask) is used to display the task list in the user's browser. The input is the calculated task priorities, and the output is the task list presented to the user.

[1650] Step 6: Recording task initiation and completion

[1651] When a user starts a task, the device records the time. When the task is completed, the device records the time again. This information is sent to a server and stored in a database. The inputs are the user's actions to start and complete the task, and the outputs are the recorded start and completion times.

[1652] Step 7: Handle urgent tasks

[1653] If an urgent task is inserted, the server re-determines the priority including the urgent task. The server updates the task list and presents it to the user again. The input is the urgent task information, and the output is the updated task list.

[1654] Step 8: Adjust task presentation with emotion engine

[1655] The server uses an emotion engine to recognize the user's emotional state. If the user feels anxious, it presents tasks one by one, and if the user feels calm, it presents multiple tasks simultaneously. The input is the user's emotional state, and the output is the adjusted task presentation method.

[1656] (Application example 2)

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

[1658] Conventional task management systems could not take into account the user's status or environment when determining task priorities, making it difficult to complete tasks efficiently. In addition, when an urgent intervening task occurred, tasks had to be reorganized manually, making it difficult to respond quickly. Furthermore, the system lacked the functionality to adjust the way tasks were presented depending on the robot's status, hindering efficient operation of the robot.

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

[1660] In this invention, the server includes a means for receiving tasks such as a request to review materials from a communication tool and preparation for a meeting, a means for determining task priority from past records, a means for organizing tasks based on priority, a means for reorganizing tasks when an urgent insertion task is received, a means for adjusting the method of presenting tasks based on the state of the robot, a means for monitoring the state of the robot, and a means for recording the execution time of tasks. This makes it possible to efficiently determine task priority and present optimal tasks according to the state of the robot.

[1661] A "Communication Tool" is any software or platform that enables users to exchange messages or information between each other.

[1662] A "document review request" is a task to review a specific document or data and request feedback or corrections.

[1663] "Preparing for a meeting" is the task of collecting and organizing the materials and information necessary for the meeting.

[1664] A "task" is a sequence of operations or activities performed to accomplish a particular goal.

[1665] "Past records" are data or information about previously performed tasks and their results.

[1666] "Priority" is an indicator of the importance and urgency of a task.

[1667] "Organization" is the process of efficiently managing tasks and determining the order in which they are to be performed.

[1668] An "urgent inject task" is a task that arises unexpectedly and requires immediate attention.

[1669] "Robot status" is information that indicates the operating status of the robot, such as the remaining battery level and temperature.

[1670] "Task presentation method" refers to how the task is displayed or communicated to the user or robot.

[1671] "Monitoring" is the process of continually checking the status and operation of a robot and responding if necessary.

[1672] "Execution time" is the time it takes from start to finish of a task.

[1673] An embodiment of the present invention will be described.

[1674] The server has a means for receiving tasks such as a request to review documents or preparation for a meeting from the communication tool. This means is realized, for example, by acquiring messages using the Slack API. The server extracts information such as the task content, sender, and sending time from the acquired messages.

[1675] Next, the server has a means for determining the priority of a task from past records. This means uses an algorithm that refers to past task data and evaluates the importance and urgency of the task. For example, the server determines the priority based on data such as how quickly similar tasks were processed in the past and how much resources were required.

[1676] The server further includes a means for sorting tasks based on priority. This means lists tasks in descending order of priority and generates a list to be presented to a user or a robot. When an urgent insertion task is received, the server sorts the tasks again and reevaluates the priorities.

[1677] The server is also equipped with a means for adjusting the way tasks are presented based on the robot's status. This means monitors the robot's operating conditions, such as the remaining battery level and temperature, and changes the way tasks are presented depending on the robot's status. For example, when the robot's battery is low, tasks are presented one at a time, reducing the burden on the robot. On the other hand, when the robot is operating normally, multiple tasks are presented simultaneously, improving productivity.

[1678] The server also includes a means for recording the execution time of a task. This means records the start and end times of a task and reflects the results in the next priority determination. This allows the efficiency of task execution to be continuously improved.

[1679] As a concrete example, consider the case where a task "Assemble part A" is sent from Slack. The server receives this message and determines the priority based on past data. If the robot's battery level is 50% and the temperature is 60 degrees, the server judges the robot's condition to be "normal" and presents multiple tasks simultaneously. The robot performs the presented tasks, and the server records the execution time.

[1680] Example of a prompt to be input to a generative AI model:

[1681] Create a program that receives messages from Slack, determines the priority of tasks, and presents tasks according to the robot's status. The robot's status includes the remaining battery level and temperature. Task priority is determined by referring to past data, and tasks are presented one at a time or multiple at the same time according to the robot's status.

[1682] In this way, the server can efficiently determine task priorities and present optimal tasks according to the robot's state.

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

[1684] Step 1:

[1685] The server receives messages from the communication tool. Specifically, it retrieves messages from a specified channel using the Slack API. The input is the message data from the Slack API, and the output is information such as the message content, sender, and sending time.

[1686] Step 2:

[1687] The server extracts the task contents from the received message. The input is the message data obtained in step 1, and the output is detailed information such as the task contents, sender, and sending time. Specifically, the server analyzes the text part of the message and extracts the parts that are recognized as tasks.

[1688] Step 3:

[1689] The server determines the task priority from past records. The input is the detailed task information extracted in step 2 and past task data, and the output is the task priority. Specifically, the server refers to the past task database and calculates the priority based on data such as how quickly similar tasks were processed and how many resources were required.

[1690] Step 4:

[1691] The server organizes tasks based on priority. The input is the task priority determined in step 3, and the output is a task list organized by priority. Specifically, it lists tasks in descending order of priority and generates a list to present to the user or robot.

[1692] Step 5:

[1693] The server reorganizes tasks when an urgent task is inserted. The input is the newly received urgent task information and the existing task list, and the output is the reorganized task list. Specifically, the priority of the urgent task is immediately evaluated and it is incorporated into the existing task list.

[1694] Step 6:

[1695] The server adjusts the task presentation method based on the robot's status. The input is the robot's status information (battery level, temperature, etc.) and the task list organized in step 4 or step 5, and the output is the adjusted task presentation method. Specifically, it monitors the robot's status, and if the battery is low, it presents tasks one by one, and if the battery is normal, it presents multiple tasks simultaneously.

[1696] Step 7:

[1697] The server records the execution time of a task. The input is the start and end time of the task, and the output is a record of the execution time. Specifically, it records the timestamps when the task is started and when it is completed, calculates the difference between them, and saves the execution time in the database.

[1698] In this way, the server can efficiently determine task priorities and present optimal tasks according to the robot's state.

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

[1700] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ) and other generation AIs. The data generation model 58 is obtained by making a neural network perform deep learning. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating a voice, text data indicating a text, and image data indicating an image is input. The data generation model 58 performs inference on the input inference data according to the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

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

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

[1703] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1717] "Example 1"

[1718] The embodiment of the present invention is a system that cooperates with a communication tool using an API, Webhook, etc., as a means for receiving tasks such as a request to review materials from the communication tool or preparation for a meeting. As a means for determining the priority of a task from past records, the priority is automatically determined using a machine learning algorithm based on information such as the completion time of the past task, the type of task, and the source of the task. As a means for organizing tasks based on priority, tasks are listed in descending order of priority and presented to the user. When an urgent insertion task is received, the tasks are organized again, and the organized tasks are presented to the user. In addition, as a means for recording the execution status of a user's task, the start time, end time, interruption time, etc. of the task are recorded, and the information is reflected in the next priority determination.

[1719] "Example 2"

[1720] As a specific example, consider a system that uses Slack as a communication tool and receives messages from Slack via an API. Based on the task content contained in the message, the time the message was sent, the sender, and other information, the system refers to the completion status of similar tasks in the past and determines the priority of a new task. Tasks are listed in order of highest priority and presented to the user. If an urgent insert task is received, the priority is determined again, including this task, and the task list is updated. When a user starts a task, the time is recorded, and when the task is completed, the time is recorded. This information is reflected in the next priority determination.

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

[1722] "Example 1"

[1723] Step 1: Receive tasks such as document review requests and meeting preparations from communication tools using APIs, Webhooks, etc.

[1724] Step 2: Based on the content of the received task, the time it was sent, the sender, and other information, the completion status of similar tasks in the past is referenced and the priority of the new task is determined.

[1725] Step 3: Present a list of tasks to the user, starting with the highest priority.

[1726] Step 4: If an urgent merge task comes in, reprioritize and update the task list to include that task.

[1727] Step 5: When a user starts a task, record the time, and when the task is completed, record the time. Use this information to inform the next priority decision.

[1728] "Example 2"

[1729] Step 1: Use Slack as a communication tool and receive messages from Slack via the API.

[1730] Step 2: Based on the task content contained in the message, the time the message was sent, the sender, and other information, the completion status of similar tasks in the past is referenced and the priority of the new task is determined.

[1731] Step 3: Present a list of tasks to the user, starting with the highest priority.

[1732] Step 4: If an urgent merge task comes in, reprioritize and update the task list to include that task.

[1733] Step 5: When a user starts a task, record the time, and when the task is completed, record the time. Use this information to inform the next priority decision.

[1734] Example 1

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

[1736] Conventional task management systems have difficulty efficiently receiving tasks from communication tools, properly determining priorities, and presenting them to users. They also lacked the functionality to reorganize tasks when an urgent insertion task occurs, or the functionality to record the user's task completion status and reflect it in the next priority determination. This made task management cumbersome for users and hindered efficient task completion.

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

[1738] In this invention, the server includes a means for receiving tasks from a communication tool, a means for analyzing the contents of the received tasks, a means for collecting past task data, a means for determining task priorities using a machine learning algorithm, a means for organizing tasks based on priorities, a means for reorganizing tasks when an urgent insertion task is received, a means for presenting the organized task list to the user, a means for recording the user's task performance status, and a means for reflecting the recorded performance status in the next priority determination. This makes it possible to consistently perform tasks from receiving them to determining priorities, organizing them, presenting them, and recording their performance status, thereby making the user's task management more efficient.

[1739] A "Communication Tool" is software or a platform that enables a user to exchange information with other users. Examples include messaging applications and video conferencing systems.

[1740] A "task" is a specific task or activity that a user needs to accomplish. Examples include requesting a document for review or preparing for a meeting.

[1741] A "server" is a computer system that processes data and provides services to other devices over a network.

[1742] "API" stands for Application Program Interface, a set of rules and tools for exchanging data and functions between different software programs.

[1743] A "Webhook" is a mechanism that sends an HTTP request to a specified URL when a specific event occurs.

[1744] A "machine learning algorithm" is a computational method for learning patterns from data and making predictions or classifications. Examples include random forests and support vector machines.

[1745] "Priority" is an indicator of the importance or urgency of a task. A task with a high priority should be completed before other tasks.

[1746] A "task list" is a list of tasks that a user needs to complete, organized according to priority.

[1747] "Performance status" is information that describes how a user is progressing through a task. Examples include the start time, end time, and interruption time of the task.

[1748] A "database" is a system for efficiently storing, searching, and managing data.

[1749] The present invention is a system for efficiently receiving tasks from a communication tool, appropriately determining priorities, and presenting them to a user. A specific embodiment of this system will be described below.

[1750] The server receives tasks from communication tools (e.g. messaging applications and video conferencing systems) using APIs or Webhooks. For example, you can set up a Slack Webhook to get task information when a new message is posted.

[1751] The server analyzes the received task contents using natural language processing (NLP) technology. For example, it extracts keywords such as "review request" or "meeting preparation" from the task title and description.

[1752] The server then collects historical task data from the database, for example using a SQL query to get the completion time and origin of review tasks for the past year.

[1753] The collected past task data is input into a machine learning algorithm (e.g., random forest or support vector machine) to predict the priority of new tasks. For example, the past data is input as features into the model, and a priority score is output.

[1754] The server sorts the tasks based on the priority score and lists them in descending order of priority, i.e., placing tasks with a higher priority score at the top of the list.

[1755] The organized task list is sent from the server to the terminal and presented to the user. The terminal displays the task list to the user and encourages the user to tackle the tasks in order of priority.

[1756] If an urgent injecting task occurs, the server re-organizes the tasks, e.g., when a new urgent task is added, it recalculates the existing task list and sends the updated list to the terminal.

[1757] The time when a user starts, finishes, or stops a task is recorded by the device. For example, when a user presses the "start button" to start a task, the start time is recorded.

[1758] The recorded performance data is sent to the server and reflected in the next priority decision. For example, the task completion time and interruption time are used as training data for the next machine learning model.

[1759] Examples

[1760] Example 1: Requesting a document review

[1761] A user receives a message on Slack saying, "Please review the document." The server receives this message and determines the priority based on the data of past review tasks. If the priority is high, the server notifies the device, "Please give priority to reviewing the document."

[1762] Example 2: Preparing for a meeting

[1763] A user receives a task in Microsoft Teams saying, "Please prepare for tomorrow's meeting." The server receives this task and determines the priority based on the data of past meeting preparation tasks. If the priority is low, the server notifies the device, "Please postpone preparation for the meeting."

[1764] Examples of prompt statements

[1765] "Please prioritize review requests for materials received via Slack. Determine the priority based on the completion time of past review tasks, the type of task, and the source of the task. If the request is high priority, notify the user."

[1766] In this way, we have specifically explained how the server, terminal, and user work together to determine and organize task priorities and present them to the user.

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

[1768] Step 1:

[1769] The server receives tasks from the communication tool using an API or Webhook.

[1770] Input: Task information from communication tools (e.g. Slack messages)

[1771] Output: Received task information

[1772] Specific operation: The server sets up a Slack webhook and receives the contents of a new message when it is posted. For example, it receives a message saying "Please review the document."

[1773] Step 2:

[1774] The server analyzes the contents of the received task.

[1775] Input: Received task information

[1776] Output: Information about the parsed tasks, such as type, origin, and deadline

[1777] Specific operation: The server uses natural language processing (NLP) technology to extract keywords such as "review request" and "meeting preparation" from the task title and description. For example, the server extracts the keyword "review request" from the message "Please review the materials."

[1778] Step 3:

[1779] The server collects past task data from a database.

[1780] Input: Information about the parsed task, such as type, origin, and due date

[1781] Output: Historical task data (e.g. completion time, task type, origin)

[1782] Specific operation: The server uses an SQL query to obtain the completion time and origin of review tasks from the database for the past year. For example, it collects past task data related to "review requests."

[1783] Step 4:

[1784] The server uses machine learning algorithms to prioritize new tasks based on the past task data it has collected.

[1785] Input: Past task data

[1786] Output: The priority score of the new task.

[1787] Specific operation: The server uses machine learning algorithms such as random forests and support vector machines to input past data as features into a model and output a priority score. For example, it calculates the priority score for a "review request."

[1788] Step 5:

[1789] The server organizes the tasks based on the priority score, listing them in order of priority.

[1790] Input: The priority score of the new task

[1791] Output: An organized task list

[1792] Specific behavior: The server will place tasks with higher priority scores at the top of the list. For example, if "review request" has a high priority score, it will be placed at the top of the list.

[1793] Step 6:

[1794] The server transmits the organized task list to the terminal and presents it to the user.

[1795] Input: An organized task list

[1796] Output: The task list presented to the user.

[1797] Specific operation: The server sends the organized task list to the terminal, and the terminal displays the task list to the user. For example, the user's screen displays "request review" as the top priority task.

[1798] Step 7:

[1799] The server re-arranges tasks if an urgent merge task occurs.

[1800] Input: Urgent mail merge task information

[1801] Output: Updated task list.

[1802] Specific operation: The server recalculates the existing task list when a new urgent task is added and sends the updated list to the terminal. For example, if "urgent meeting preparation" is added, the task list is reorganized.

[1803] Step 8:

[1804] The device records the time when a user starts, finishes, and stops a task.

[1805] Input: User task performance (start time, end time, interruption time)

[1806] Output: Logged performance data

[1807] Specific operation: When a user starts a task, the device records the start time by pressing the "Start" button. Similarly, when the user finishes the task, the device records the end time by pressing the "End" button.

[1808] Step 9:

[1809] The server reflects the recorded performance data in the next priority determination.

[1810] Input: Recorded performance data

[1811] Output: An updated machine learning model.

[1812] Specific operation: The server stores the progress data received from the terminal in a database and uses it as training data for the next machine learning model, for example, to reflect the task completion time and interruption time in the next priority determination.

[1813] (Application example 1)

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

[1815] Conventional factory robots required manual task prioritization, making efficient task management difficult. In addition, when an urgent intervening task occurred, it was difficult to quickly reset task priorities, which could result in work delays and reduced efficiency. Furthermore, there was an insufficient means of recording the task execution status, making it impossible to reflect this in the next task priority determination.

[1816] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means. In this invention, the server includes a means for receiving tasks such as a request for reviewing materials from a communication tool and preparation for a meeting, a means for determining the priority of tasks from past records, a means for organizing tasks based on the priority, a means for reorganizing tasks when an urgent insertion task is received, a means for receiving tasks from a management system or a communication tool in a factory, a means for determining the priority of tasks using a machine learning algorithm based on past task data, a means for listing tasks in order of priority and presenting them to a robot, and a means for recording the start time, end time, interruption time, etc. of a task and reflecting them in the next priority determination. This enables the factory robot to efficiently manage tasks and quickly respond to urgent tasks, thereby preventing work delays and efficiency declines.

[1817] A "communication tool" is software or an application that allows users to exchange information between each other.

[1818] A "material review request" is a request to review and provide feedback on specific documents or data.

[1819] "Preparing for a meeting" refers to the task of gathering the materials and information necessary to ensure the meeting proceeds smoothly.

[1820] A "task" is an operation or activity that must be performed to achieve a particular purpose.

[1821] "Past records" are data about previously performed tasks and their results.

[1822] "Priority" is an indicator of the importance and urgency of a task.

[1823] A "machine learning algorithm" is a computational technique for learning patterns from data and making predictions or classifications.

[1824] "Factory management systems" is a general term for software and hardware used to manage factory operations and production activities.

[1825] The "start time of a task" is the time when the task actually starts.

[1826] "Task end time" is the time when the task is completed.

[1827] A "task suspension time" is a period of time during which a task is temporarily stopped.

[1828] A "robot" is a mechanical device that performs specific tasks automatically.

[1829] "Task progress status" is information that indicates the state or progress of a task.

[1830] A system for carrying out the present invention includes an application installed on a robot used in a factory. A specific embodiment of this system will be described below.

[1831] System Configuration

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

[1833] 1. Communication tools: Software or applications that allow users to exchange information between each other.

[1834] 2. Factory management systems: Software and hardware for managing factory operations and production activities.

[1835] 3. Robot: A mechanical device used to perform specific tasks automatically. 【183...

Claims

1. A means for receiving tasks from a communication tool; A means for obtaining task data relating to previously recorded tasks; means for determining a priority of the received task based on the acquired task data; means for generating a task list organized based on the priority; means for presenting said task list to a user; A system including:

2. 2. The system of claim 1, wherein the means for determining task priority recognizes an emotional state of the user and determines the priority of the task based on the task data and the emotional state.

3. 2. The system according to claim 1, wherein the means for determining the priority of the task determines the priority of the task using a prompt sentence received from the communication tool and a generative AI that instructs the user to determine the priority of the task.

Images