System

Abstract

A system is provided.SOLUTION: This system is provided with a means for acquiring task information from an external system, a means for storing the acquired task information in a database, a means for preparing a daily report based on the information of the database and a means for preserving the daily report in a prescribed format.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] In modern project management and progress reporting, when employees individually create daily and weekly reports, it takes a lot of time and effort, resulting in reduced work efficiency. Furthermore, the quality of the reports often depends on the skills and experience of each employee, resulting in a lack of consistency. This situation makes it difficult to accurately grasp the progress of the entire company, making project management cumbersome. Another problem is that employees spend time creating daily and weekly reports, which distracts them from their core work. [Means for solving the problem]

[0005] The present invention solves the above-mentioned problems by providing a system that acquires task information from an external system and stores the acquired task information in a database. It also provides a system that automatically creates daily reports based on the information in the database and saves them in a specified format. Specifically, the system uses an application programming interface as a means for acquiring task information from the external system, and also includes a means for automatically creating weekly reports based on the daily reports. This significantly reduces the workload of employees, standardizes the quality of reports, and streamlines company-wide progress management.

[0006] An "external system" is an application used for project management or task management, and is a system that provides task information via an API.

[0007] "Task information" is detailed information about a task related to a project, and specifically includes information such as the task name, person in charge, status, start date, and end date.

[0008] A "database" is a digital storage system for saving and managing data such as acquired task information and generated daily and weekly reports.

[0009] A "daily report" is a written report in which each employee reports on the work and progress of the day.

[0010] A "weekly report" is a written report that summarizes the work content and progress over the course of a week.

[0011] "Automatically generated" means that the system generates reports and data programmatically without human intervention.

[0012] A "prescribed format" is a defined layout or style that ensures reports and data are created and stored in a uniform format.

[0013] An "application programming interface (API)" is a defined method or rule for different software programs to interact with each other and exchange data. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0022] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0035] The present invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[0036] 1. Obtaining task information from an external system

[0037] The server sends a request to an external system (e.g., a project management tool or task management tool) via API to obtain the necessary task information, including the task name, assignee, status, start date, end date, etc.

[0038] Natural language explanations

[0039] The server sends API requests to external systems to retrieve information about projects and tasks, including task names, assignees, statuses, start and end dates, and so on, and stores this data in a database.

[0040] Specific examples

[0041] For example, when the server retrieves task information for "Project ABC" from a project management tool, it sends an API request and receives task information in response, including the task name "Design Review," the person in charge "Yamada Taro," the status "In Progress," the start date "2023-10-01," and the end date "2023-10-05."

[0042] 2. Store task information in a database

[0043] The server stores the acquired task information in a database, allowing the data required for subsequent processing to be quickly referenced.

[0044] Natural language explanations

[0045] The server stores the task information obtained from the external system in a database, which is used to generate future daily and weekly reports.

[0046] Specific examples

[0047] If the task information obtained from the project management tool is a "design review" task, save this information to the database. The fields saved in the database include the task ID, name, assignee, status, time log, etc.

[0048] 3. Generate daily reports

[0049] The server automatically generates daily reports for each employee based on task information retrieved from the database, detailing the work and progress of that day.

[0050] Natural language explanations

[0051] The server automatically generates daily reports for each employee based on task information in the database. The daily reports contain detailed information about the work done that day and the progress made, allowing employees to submit reports of a consistent quality without any effort.

[0052] Specific examples

[0053] For example, when generating a daily report for employee "Yamada Taro," the server automatically creates the report based on the task information for that day (e.g., task name "Design Review," status "Complete"). The daily report will include information such as "Today's Task: Design Review, Status: Completed, Work Time: 5 hours."

[0054] 4. Generate weekly reports

[0055] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. This weekly report is used to grasp the overall progress of the project.

[0056] Natural language explanations

[0057] The server automatically generates a weekly report summarizing the progress of a specific week based on the daily report data, allowing the progress of the entire project to be grasped at a glance.

[0058] Specific examples

[0059] For example, to check weekly progress, the server aggregates the daily report data in the database and generates a weekly report that includes information such as "Weekly tasks: Design review, Project ABC, Number of completed tasks: 5, Number of remaining tasks: 2."

[0060] 5. Saving the report

[0061] The server saves the generated daily and weekly reports in a specified format. Based on this format, the reports are saved in a unified format, making them easy for readers to understand.

[0062] Natural language explanations

[0063] The server stores automatically generated daily and weekly reports in a specified format, which allows the reports to be presented in a standardized format that is easy for readers to understand.

[0064] Specific examples

[0065] For example, when saving a daily report generated by the server, it saves it to a file in a specific format (e.g., Markdown or Excel format). This file is saved in a format such as "2023-10-05_Yamada Taro_DailyReport.md."

[0066] As described above, the system of the present invention can streamline and standardize work reporting and progress management by acquiring data from external systems, storing it in a database, automatically generating daily and weekly reports, and saving the reports in a specified format. This significantly reduces the workload of employees and improves the performance of the entire company.

[0067] The processing flow will be explained below.

[0068] Step 1:

[0069] The server sends a request to the API endpoint of the external system to obtain the required task information.

[0070] Specific actions

[0071] The server configures the API endpoint of the external system, along with the necessary query parameters and authentication information, and sends an API request to retrieve project and task information (e.g., task name, assignee, status, start date, end date, etc.).

[0072] python

[0073] url = "https: / / external-system.com / api / tasks"

[0074] params = {'project_id': 'ABC123'}

[0075] headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}

[0076] response = requests.get(url, params=params, headers=headers)

[0077] Step 2:

[0078] The server analyzes the response received from the external system and extracts the required information.

[0079] Specific actions

[0080] The server parses the API response in JSON format and extracts the required fields (e.g. task ID, name, assignee, status, time log, etc.) This data is either kept temporarily in memory for further processing or stored immediately in a database.

[0081] python

[0082] if response.status_code == 200:

[0083] tasks = response.json()

[0084] for task in tasks:

[0085] task_id = task['id']

[0086] task_name = task['name']

[0087] assignee = task['assignee']

[0088] status = task['status']

[0089] Processing to save to the database

[0090] Step 3:

[0091] The server stores the analyzed task information in a database.

[0092] Specific actions

[0093] The server saves the extracted task information to the appropriate table in the database by inserting each field (task ID, name, assignee, status, time log, etc.) into the corresponding column in the database.

[0094] python

[0095] def save_to_database(task):

[0096] connection = get_database_connection()

[0097] cursor = connection.cursor()

[0098] insert_query = """INSERT INTO tasks (task_id, name, assignee, status, time_log) VALUES (%s, %s, %s, %s, %s)"""

[0099] cursor.execute(insert_query, (task['id'], task['name'], task['assignee'], task['status'], task['time_log']))

[0100] connection.commit()

[0101] cursor.close()

[0102] connection.close()

[0103] Step 4:

[0104] The server retrieves task information for each employee from the database and generates a daily report.

[0105] Specific actions

[0106] The server queries the database for task information for each employee and automatically generates daily reports based on that information, including task name, person in charge, status, and work time.

[0107] python

[0108] employee_id = "yamada_taro"

[0109] jira_tickets = get_jira_tickets(employee_id)

[0110] confluence_updates = get_confluence_updates(employee_id)

[0111] commits = get_commit_history(employee_id)

[0112] daily_report = f"""

[0113] Daily report for {datetime.now().date()}

[0114] JIRA Tickets

[0115] {jira_tickets}

[0116] Confluence Update History

[0117] {confluence_updates}

[0118] Commit History

[0119] {commits}

[0120] """

[0121] Step 5:

[0122] The server saves the generated daily report in a specified format.

[0123] Specific actions

[0124] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format). This operation ensures that the daily reports are stored in a unified format, making them easier to refer to later.

[0125] python

[0126] with open(f" / path / to / reports / {employee_id}_daily_report.txt", "w") as file:

[0127] file.write(daily_report)

[0128] Step 6:

[0129] The server automatically generates a weekly report based on the daily report.

[0130] Specific actions

[0131] The server aggregates the daily report data stored in the database and generates a weekly report that reflects the progress for one week. The weekly report includes the progress of each task, the number of completed tasks, and the number of uncompleted tasks.

[0132] python

[0133] week_start = "2023-10-01"

[0134] week_end = "2023-10-07"

[0135] weekly_reports = get_weekly_reports(week_start, week_end)

[0136] weekly_report = f"""

[0137] Weekly report from {week_start} to {week_end}

[0138] {weekly_reports}

[0139] """

[0140] Step 7:

[0141] The server saves the generated weekly report in a specified format.

[0142] Specific actions

[0143] The server saves the generated weekly reports in a specific folder in a specified format. This operation ensures that the weekly reports are stored in a standardized format, making it easier to manage the progress of the entire project.

[0144] python

[0145] with open(" / path / to / reports / weekly_report.txt", "w") as file:

[0146] file.write(weekly_report)

[0147] The above are the specific processing steps of the present invention. Through each step, daily and weekly reports can be automatically generated efficiently and in a unified format, reducing the workload of employees and improving the efficiency of company-wide progress management.

[0148] Example 1

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

[0150] Conventional task management systems require the manual collection and organization of diverse project and task information, resulting in workload burdens and a high likelihood of management errors. Handling and recording information, especially when creating daily and weekly reports, takes time and effort. In addition, inconsistent formats can make reports difficult for readers to understand. There is a need to solve these problems and achieve efficient, standardized task management and report creation.

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

[0152] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating a daily report based on the information in the database, means for saving the daily report in a predetermined format, and means for creating a weekly report, thereby enabling automatic acquisition of task information and efficient storage in the database, as well as automatic generation and saving of standardized daily and weekly reports.

[0153] "External system" refers to a system that manages and provides task information, and includes software such as project management tools and task management tools.

[0154] "Task information" is detailed information about a project or work unit, including the task name, person in charge, status, start date, and end date.

[0155] "Database" refers to an information storage system that stores acquired task information and allows for quick reference in subsequent processing.

[0156] A "daily report" is a report that details the progress and work content of tasks on a specific day.

[0157] A "weekly report" is a report that summarizes the progress of tasks for the week and helps you understand the progress of the entire project.

[0158] An "application programming interface (API)" refers to an interface for exchanging data between different software programs.

[0159] An "authentication token" is security information used when sending an API request to verify that the request is legitimate.

[0160] "JSON format" is an abbreviation for JavaScript Object Notation, and is a lightweight data exchange format for expressing data structures in text format.

[0161] "SQL statement" stands for Structured Query Language and is an instruction for interacting with a database management system.

[0162] A "template engine" is a software component that embeds dynamic data into standard text and is used to automatically generate reports.

[0163] The Markdown format is a lightweight markup language for writing plain text, and is a format that pursues ease of reading and writing.

[0164] "Excel format" is a file format used by Microsoft Excel, a spreadsheet software, for organizing data and performing calculations.

[0165] The present invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[0166] Retrieving task information from an external system

[0167] The server sends a request to an external system (e.g., a project management tool or task management tool) via API to obtain the required task information. To do this, the server uses a pre-prepared URL and authentication token. The obtained task information is then parsed in JSON format. Task information includes the task name, assignee, status, start date, end date, etc.

[0168] Specific examples

[0169] For example, when a server retrieves task information for "Project XYZ" from a project management tool, it sends an API request and receives task information in response, including the task name "Design Review," the assignee "Ichiro Sato," the status "In Progress," the start date "2023-11-01," and the end date "2023-11-05."

[0170] Store task information in a database

[0171] The server converts the acquired task information into SQL statements and stores them in a database. The database is SQL-based and saves the information in a format that corresponds to each field (task ID, name, person in charge, status, start date, end date, etc.).

[0172] Specific examples

[0173] After retrieving the "Design Review" task from the project management tool, save this information to the database using the SQL statement "INSERT INTO tasks (task_id, name, status, start_date, end_date) VALUES (1, 'Design Review', 'In Progress', '2023-11-01', '2023-11-05')".

[0174] Generate daily reports

[0175] The server automatically generates daily reports for each employee based on task information retrieved from the database. Daily reports are created using a template engine (e.g., Jinja2) and include detailed information about the work and progress of that day.

[0176] Specific examples

[0177] For example, when generating a daily report for employee "Ichiro Sato," the server automatically creates the report based on the task information for that day (e.g., task name "Design Review," status "Complete"), and uses a template to generate a daily report with content such as "Today's Task: Design Review, Status: Completed, Work Time: 5 hours."

[0178] Generate weekly reports

[0179] The server automatically generates weekly reports summarizing progress on a weekly basis based on the daily report data. Weekly reports are also created using a template engine.

[0180] Specific examples

[0181] For example, to see progress for a particular week, the server aggregates the daily report data and generates a weekly report that might include something like "Weekly tasks: Design Review, Project XYZ, Number of completed tasks: 5, Number of remaining tasks: 2."

[0182] Save the report

[0183] The server saves the generated daily and weekly reports in a specified format, such as Markdown or Excel. The saved reports are managed in a specific directory.

[0184] Specific examples

[0185] For example, files will be saved in formats such as "2023-11-05_Sato Ichiro_DailyReport.md" or "2023-W45_WeeklyReport.xlsx".

[0186] As described above, the system of the present invention can streamline and standardize work reports and progress management by acquiring data from external systems, storing it in a database, automatically generating daily and weekly reports, and saving the reports in a specified format. This is expected to significantly reduce the workload of employees and improve the performance of the entire company.

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

[0188] Step 1:

[0189] Retrieving task information from an external system

[0190] The server sends an API request to the external system to obtain the required task information. To do this, the server sends an HTTP GET request including a previously prepared URL and authentication token. The input required is the API endpoint of the external system and the authentication token. The output is the task information in JSON format, which is returned as a response. Specifically, the server constructs an HTTP request including the authentication token in the header and sends it to the API endpoint. The response is then parsed to extract the required task information.

[0191] Step 2:

[0192] Parsing task information and storing it in a database

[0193] The server parses the acquired JSON formatted task information and stores it in the database. The JSON data acquired in step 1 is required as input. The output is the task information stored in the database. Specifically, the server parses the acquired JSON data and extracts each field (task ID, name, assignee, status, start date, end date, etc.). It then generates an SQL statement and executes the INSERT statement on the database.

[0194] Step 3:

[0195] Generate daily reports

[0196] The server retrieves task information from the database and automatically generates daily reports for each employee. The input requires task information stored in the database. The output is the automatically generated daily report. Specifically, the server uses an SQL SELECT statement to retrieve task information for a specific employee from the database. It then uses a template engine (e.g., Jinja2) to embed the information in a template and generate the daily report.

[0197] Step 4:

[0198] Generate weekly reports

[0199] The server automatically generates weekly reports based on daily reports. The input requires daily report data from the database. The output is the generated weekly report. Specifically, the server uses an SQL SELECT statement to retrieve daily report data within a specific week range. It then aggregates this daily report data and generates the weekly report using a template engine.

[0200] Step 5:

[0201] Save the report

[0202] The server saves the generated daily and weekly reports in a specified format (Markdown or Excel). The automatically generated daily and weekly reports are required as input. The output is a file saved in the specified format. Specifically, the server uses a template engine to convert the generated report into a Markdown or Excel file and saves it in a specified directory. For example, the file is saved in a format such as "2023-11-05_EmployeeA_DailyReport.md" or "2023-W45_WeeklyReport.xlsx."

[0203] (Application example 1)

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

[0205] With conventional factory task management systems, it was difficult to accurately grasp the work progress of each robot and automatically generate daily and weekly reports. Furthermore, checking the progress of tasks performed by individual robots required a lot of manual work, which was inefficient and prone to information being lost. This resulted in a decline in overall productivity and made it difficult to share information in a timely manner.

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

[0207] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating daily reports based on the information in the database, means for saving the daily reports in a predetermined format, means for acquiring task information from a robot control system, storing the task information in a database, and saving daily and weekly reports automatically generated based on the robot's work progress, and means for checking the task progress status for a specified period using a generative AI model. This makes it possible to efficiently manage the robot's work progress and automatically generate and save daily and weekly reports.

[0208] An "external system" is an information system that provides task information from data outside the factory, project management tools, etc.

[0209] "Task information" is data consisting of information such as specific work content, person in charge, status, start date, and end date.

[0210] A "database" is a structured data storage system that stores acquired task information and allows quick reference as needed.

[0211] A "daily report" is a report detailing the work and progress of each robot on a particular day.

[0212] A "weekly report" is a report summarizing the progress of work during a particular week.

[0213] A "robot control system" is a system for managing and controlling the operation of robots within a factory.

[0214] A "generative AI model" is an artificial intelligence algorithm that identifies and analyzes task progress over a specified period of time.

[0215] A "prescribed format" is a document format that is established so that reports are saved in a unified format and are easy for readers to understand.

[0216] This invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is realized through the cooperation of a server, terminals, and users.

[0217] 1. Obtaining task information from an external system

[0218] The server sends a request via API to an external system (for example, an external data or project management tool) to obtain the required task information. Task information includes the task name, person in charge, status, start date, and end date. Specifically, the server uses the API of the factory's robot control system to obtain the work progress of each robot. This information includes the work content, the robot responsible for the work, the progress status, and the start and end dates.

[0219] 2. Store task information in a database

[0220] The server stores the acquired task information in a database, allowing for quick reference of the data required for subsequent processing. The database is configured using SQLite and stores detailed data for each task.

[0221] 3. Generate daily reports

[0222] The server automatically generates a daily report for each robot based on task information retrieved from the database. This daily report contains detailed information about the work and progress of that day. Specifically, the server extracts information about tasks performed on a specific day and automatically creates a daily report.

[0223] 4. Generate weekly reports

[0224] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. This allows you to grasp the overall progress status. The server aggregates the weekly task data and compiles it into a weekly report.

[0225] 5. Saving the report

[0226] The server saves the generated daily and weekly reports in a specified format. Based on this format, the reports are saved in a unified format, making them easy for readers to understand. For example, Markdown or Excel is used as the saving format.

[0227] 6. Leveraging generative AI models

[0228] The server uses the generative AI model to check the progress of a task over a specified period, allowing users to view the progress and time spent on a specific task through prompts.

[0229] For example, use the following prompt:

[0230] "I would like to check the progress of a specific task. Please let me know whether Robot A has completed the 'Parts assembly' task and how long it took between the start dates of 2023-10-01 and 2023-10-07."

[0231] With the above functions, the present invention can efficiently manage the work progress of robots in a factory and automatically generate and save daily and weekly reports.

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

[0233] Step 1:

[0234] The server obtains task information from an external system. Specifically, it sends an API request and receives task information as a response. The input is the API endpoint and authentication information of the external system, and the output is task information including the task name, person in charge, status, start date, and end date. For example, the API of a robot control system is used to obtain data on the work performed by a specific robot.

[0235] Step 2:

[0236] The server stores the acquired task information in the database. Specifically, it executes an INSERT query on the SQLite database. The input is the task information acquired in step 1, and the output is the task information stored in the database. This means that detailed data of each task (such as name, assignee, progress status, etc.) is accurately stored in the database.

[0237] Step 3:

[0238] The server automatically generates daily reports based on task information retrieved from the database. Specifically, it extracts task data related to a specific date using an SQL query and embeds it in a template. A specific date is specified as input, and the output is a daily report text that describes the work and progress of that day. For example, it generates a daily report that includes information that the "design review" task was completed that day.

[0239] Step 4:

[0240] The server automatically generates weekly reports based on the daily report information stored in the database. Specifically, it aggregates the daily report data for a specified week and embeds it back into the template. The input is the start and end dates, and the output is a weekly report text summarizing the progress for the week. For example, a weekly report can be generated that displays the number of tasks completed and the number of tasks remaining in a specific week.

[0241] Step 5:

[0242] The server saves the generated daily and weekly reports in a specified format. Specifically, the generated report text data is saved as a file in Markdown or Excel format. The input is the report text data, and the output is a file in the specified format. For example, the report is saved with a file name such as "2023-10-05_dailyreport.md".

[0243] Step 6:

[0244] The server uses the generative AI model to check the task progress for a specified period. Specifically, it analyzes the prompt text entered by the user, extracts the corresponding task data from the database, and processes it. The input is the prompt text entered by the user, and the output is the analysis results regarding the progress and work time within the specified period. For example, it can check progress such as "Has Robot A completed the 'assembly of parts' task?"

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

[0246] This invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information, in addition to combining it with an emotion engine that recognizes the user's emotions. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[0247] 1. Obtaining task information from an external system

[0248] The server sends a request via API to an external system (e.g., a project management tool or task management tool) to retrieve the required task information, including the task name, assignee, status, start date, end date, etc.

[0249] Natural language explanations

[0250] The server sends API requests to external systems to retrieve information about projects and tasks, which is then stored in a database.

[0251] Specific examples

[0252] For example, when a server retrieves task information for "Project ABC" from a project management tool, it sends an API request and receives task information (e.g., task name "Design Review," task owner "Yamada Taro," status "In Progress," etc.) in response.

[0253] 2. Store task information in a database

[0254] The server stores the acquired task information in a database, allowing the data required for subsequent processing to be quickly referenced.

[0255] Natural language explanations

[0256] The server stores task information obtained from external systems in a database. The saved data is used to generate daily and weekly reports.

[0257] Specific examples

[0258] The acquired task information (e.g., task name "Design Review", task owner "Yamada Taro", status "In Progress", start date "2023-10-01", end date "2023-10-05", etc.) is saved in the database.

[0259] 3. Emotion Recognition by Emotion Engine

[0260] The device receives voice input and facial recognition data from the user and analyzes the user's emotions using an emotion engine.

[0261] Natural language explanations

[0262] The device uses an emotion engine to analyze the user's emotions based on the user's voice input and facial recognition data obtained from camera footage. The analysis results influence the generation of subsequent daily reports.

[0263] Specific examples

[0264] When a user inputs voice into the device, the device sends the voice to the emotion engine, which analyzes the voice and recognizes emotions such as "joy," "sadness," and "anger."

[0265] 4. Generate daily reports

[0266] The server automatically generates daily reports for each employee based on task information retrieved from the database and the results of the emotion engine's analysis. The content of the daily reports is adjusted based on the results of the emotion analysis.

[0267] Natural language explanations

[0268] The server automatically generates the contents of the daily report based on the task information in the database and the results of emotion analysis, so that the user's mood and emotions are reflected in the daily report.

[0269] Specific examples

[0270] When generating a daily report for user "Yamada Taro," the server generates a daily report with content such as "Today, we progressed with the design review. It is progressing smoothly and I am very satisfied." based on task information (e.g., "Design review, in progress, 5 hours of work") and emotion analysis results (e.g., "Delighted").

[0271] 5. Saving daily reports

[0272] The server saves the generated daily reports in a predetermined format, which allows the daily reports to be saved in a unified format.

[0273] Natural language explanations

[0274] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format), so that the daily reports are stored in a unified format.

[0275] Specific examples

[0276] Save the generated daily report in a format such as "2023-10-05_Yamada Taro_DailyReport.md".

[0277] 6. Generate weekly reports

[0278] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database, and also takes into account the results of sentiment analysis.

[0279] Natural language explanations

[0280] The server automatically generates a weekly report summarizing the progress of a specific week based on the daily report data. The results of sentiment analysis are also reflected in the weekly report.

[0281] Specific examples

[0282] A weekly report is generated based on task information for the specified week (e.g., "5 completed tasks, 2 incomplete tasks") and sentiment analysis results (e.g., "Overall satisfaction was high this week").

[0283] 7. Saving weekly reports

[0284] The server saves the generated weekly reports in a predetermined format, which allows the weekly reports to be saved in a unified format.

[0285] Natural language explanations

[0286] The server saves the generated weekly reports in a specific folder in a specified format, so that the weekly reports are stored in a unified format.

[0287] Specific examples

[0288] Save the generated weekly report in the format "2023-10-01_To_2023-10-07_WeeklyReport.md".

[0289] The above is a specific embodiment of the present invention. By combining it with an emotion engine, it is possible to realize an advanced reporting system that not only manages tasks and reports progress, but also takes into account the emotions of users. This allows reports to be created that reflect the moods and motivations of employees, which is expected to improve the performance of the entire company.

[0290] The processing flow will be explained below.

[0291] Step 1:

[0292] The server sends a request to the API endpoint of the external system to obtain the required task information.

[0293] Specific actions

[0294] The server configures the API endpoint of the external system, along with the necessary query parameters and authentication information, and sends an API request to retrieve project and task information (e.g., task name, assignee, status, start date, end date, etc.).

[0295] python

[0296] url = "https: / / external-system.com / api / tasks"

[0297] params = {'project_id': 'ABC123'}

[0298] headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}

[0299] response = requests.get(url, params=params, headers=headers)

[0300] Step 2:

[0301] The server analyzes the response received from the external system and extracts the required information.

[0302] Specific actions

[0303] The server parses the API response in JSON format and extracts the required fields (e.g. task ID, name, assignee, status, time log, etc.) This data is either kept temporarily in memory for further processing or stored immediately in a database.

[0304] python

[0305] if response.status_code == 200:

[0306] tasks = response.json()

[0307] for task in tasks:

[0308] task_id = task['id']

[0309] task_name = task['name']

[0310] assignee = task['assignee']

[0311] status = task['status']

[0312] Processing to save to the database

[0313] Step 3:

[0314] The server stores the analyzed task information in a database.

[0315] Specific actions

[0316] The server saves the extracted task information to the appropriate table in the database by inserting each field (task ID, name, assignee, status, time log, etc.) into the corresponding column in the database.

[0317] python

[0318] def save_to_database(task):

[0319] connection = get_database_connection()

[0320] cursor = connection.cursor()

[0321] insert_query = """INSERT INTO tasks (task_id, name, assignee, status, time_log) VALUES (%s, %s, %s, %s, %s)"""

[0322] cursor.execute(insert_query, (task['id'], task['name'], task['assignee'], task['status'], task['time_log']))

[0323] connection.commit()

[0324] cursor.close()

[0325] connection.close()

[0326] Step 4:

[0327] The device receives the user's voice input and camera footage and sends them to an emotion recognition engine.

[0328] Specific actions

[0329] The device receives voice input from the user and camera footage in real time and sends the voice and image data to the emotion recognition engine.

[0330] python

[0331] def capture_user_input():

[0332] audio_data = record_audio()

[0333] video_data = capture_video()

[0334] return audio_data, video_data

[0335] Step 5:

[0336] The emotion recognition engine analyzes voice input and camera footage to recognize the user's emotions.

[0337] Specific actions

[0338] The emotion recognition engine analyzes the acquired voice and image data to recognize the user's emotions (e.g., joy, sadness, anger, etc.). The analysis results are sent to the server.

[0339] python

[0340] def analyze_emotion(audio_data, video_data):

[0341] emotion_results = emotion_engine.process(audio_data, video_data)

[0342] return emotion_results

[0343] Step 6:

[0344] The server stores the emotion recognition results in a database.

[0345] Specific actions

[0346] The server stores the analysis results (e.g., type and intensity of emotion) received from the emotion recognition engine in an appropriate table in the database.

[0347] python

[0348] def save_emotion_to_database(employee_id, emotion_results):

[0349] connection = get_database_connection()

[0350] cursor = connection.cursor()

[0351] insert_query = """INSERT INTO emotions (employee_id, emotion, intensity) VALUES (%s, %s, %s)"""

[0352] cursor.execute(insert_query, (employee_id, emotion_results['emotion'], emotion_results['intensity']))

[0353] connection.commit()

[0354] cursor.close()

[0355] connection.close()

[0356] Step 7:

[0357] The server retrieves task information and emotion recognition results for each employee from the database and generates a daily report.

[0358] Specific actions

[0359] The server issues a query to retrieve task information and emotion recognition results from the database for each employee, and automatically generates a daily report based on that information. The generated report includes information such as task name, person in charge, status, working time, and type and intensity of emotion.

[0360] python

[0361] employee_id = "yamada_taro"

[0362] tasks = get_tasks(employee_id)

[0363] emotions = get_emotions(employee_id)

[0364] daily_report = f"""

[0365] Daily report for {datetime.now().date()}

[0366] task

[0367] {tasks}

[0368] emotions

[0369] {emotions}

[0370] """

[0371] Step 8:

[0372] The server saves the generated daily report in a specified format.

[0373] Specific actions

[0374] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format). This operation ensures that the daily reports are stored in a unified format, making them easier to refer to later.

[0375] python

[0376] with open(f" / path / to / reports / {employee_id}_daily_report.txt", "w") as file:

[0377] file.write(daily_report)

[0378] Step 9:

[0379] The server automatically generates a weekly report based on the daily report.

[0380] Specific actions

[0381] The server aggregates the daily report data stored in the database and generates a weekly report that reflects the progress and sentiment analysis results for the week. The weekly report includes the progress of each task, the number of completed tasks, the number of incomplete tasks, and an overview of the user's sentiment.

[0382] python

[0383] week_start = "2023-10-01"

[0384] week_end = "2023-10-07"

[0385] weekly_reports = get_weekly_reports(week_start, week_end)

[0386] weekly_report = f"""

[0387] Weekly report from {week_start} to {week_end}

[0388] {weekly_reports}

[0389] """

[0390] Step 10:

[0391] The server saves the generated weekly report in a specified format.

[0392] Specific actions

[0393] The server saves the generated weekly reports in a specific folder in a specified format. This operation ensures that the weekly reports are stored in a standardized format, making it easier to manage the progress of the entire project.

[0394] python

[0395] with open(" / path / to / reports / weekly_report.txt", "w") as file:

[0396] file.write(weekly_report)

[0397] These are the specific processing steps of the present invention. By combining it with an emotion engine, it is possible to realize an advanced reporting system that not only manages tasks and reports progress, but also takes into account the emotions of users. This allows reports to be created that reflect the moods and motivations of employees, which is expected to improve the performance of the entire company.

[0398] Example 2

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

[0400] In today's work environment, task management and progress reporting are important, but one-way reporting systems that don't take into account employee emotions and motivation have limitations in improving work efficiency and employee satisfaction. Furthermore, manually creating daily and weekly reports is time-consuming and labor-intensive, making them inefficient. To solve these problems, a reporting system that combines automatic task information acquisition and emotion analysis is needed.

[0401] 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 acquiring task information from an external system, a means for storing the acquired task information in a database, a sentiment analysis means for analyzing the user's sentiment, a means for creating a daily report based on the information in the database and the sentiment analysis results, and a means for saving the daily report in a predetermined format. This makes it possible to automatically generate a report that integrates task information and sentiment information, thereby realizing advanced task management and progress reporting that reflects the sentiments of employees.

[0402] An "external system" is a system that provides task information, such as a project management tool or a task management tool.

[0403] "Task information" is a series of information about a task, such as the task name, person in charge, status, start date, and end date.

[0404] A "database" is a data storage system that stores acquired task information and enables quick reference to data required for subsequent processing.

[0405] The "emotion analysis means" is a system that analyzes the user's voice input and facial recognition data, and identifies the user's emotions as labels such as "joy," "sadness," and "anger."

[0406] A "daily report" is a report summarizing daily work and progress based on database information and sentiment analysis results.

[0407] A "weekly report" is a report that summarizes progress on a weekly basis based on daily reports.

[0408] A "prescribed format" is a standardized file format that ensures reports are saved in a consistent format, including Markdown and Excel formats.

[0409] This invention is a system that acquires task information from an external system, stores it in a database, and then analyzes user emotions to automatically generate daily and weekly reports. This system is implemented mainly with the cooperation of a server, terminals, and users.

[0410] Hardware and Software Configuration

[0411] The server connects to external systems via an application programming interface (API) for communicating with project management tools and task management tools. The server also requires a database connection driver such as ODBC or JDBC to store the acquired task information in a database. Programming languages ​​and libraries such as Python or Java are also used to generate daily and weekly reports using sentiment analysis and generative AI models.

[0412] The device has hardware and software to capture user voice input and camera footage and send it to an emotion analysis engine, including a microphone, camera, and voice and facial recognition software.

[0413] The user uses a terminal to input data (audio, video, etc.) for the daily report. The audio and video data input by the user is sent to the emotion analysis engine via the terminal.

[0414] Specific operation of the system

[0415] 1. Get task information

[0416] The server sends an HTTP request to the API of the external system to obtain task information. The obtained information is received in JSON format and parsed. For example, obtain task information for "Project XYZ" from a project management tool.

[0417] 2. Storage in the database

[0418] The server uses SQL INSERT and UPDATE statements to store the retrieved task information in the database, so that the task information is saved in the database and can be quickly referenced at any time.

[0419] 3. Emotion analysis

[0420] The device receives voice input and camera footage from the user and sends it to an emotion analysis engine. The analysis engine analyzes the audio and video data and identifies the user's emotion as a label such as "happiness," "sadness," or "anger." For example, if a user says to the device, "Today's meeting was very constructive," the emotion engine will interpret it as "happiness."

[0421] 4. Generate daily and weekly reports

[0422] The server generates a daily report based on task information retrieved from the database and the results of sentiment analysis. A generative AI model is used in this process. A prompt such as "Please generate a daily report based on today's work content and emotions" is sent to the model. The generated daily report is saved in a specified format such as Markdown or Excel.

[0423] 5. Saving and Referencing

[0424] Daily reports are saved in a specific folder by the server, and weekly reports are saved in the same way. For example, the daily report is saved as "2023-10-05_EmployeeA_DailyReport.md" and the weekly report is saved as "2023-10-01_To_2023-10-07_WeeklyReport.md".

[0425] In this way, by automatically generating reports that integrate task information and emotional information, it is possible to achieve advanced task management and progress reports that reflect employees' emotions, enabling effective business operations that take into account employees' moods and motivations.

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

[0427] Step 1:

[0428] The server obtains task information from an external system. Specifically, the server sends an HTTP GET request to the external system's API and receives task information in JSON format. The input is the API request parameters (e.g., project ID), and the output is the JSON-formatted task information received as a response. The server parses this task information and extracts the necessary data items (e.g., task name, assignee, status, start date, and end date).

[0429] Step 2:

[0430] The server stores the extracted task information in a database. The input is the extracted task information, and the output is the newly added or updated data in the database. Specifically, the server generates SQL INSERT or UPDATE statements and executes them against the database via ODBC or JDBC. This saves the task information in the database.

[0431] Step 3:

[0432] The device receives voice input and camera footage from the user and prepares it as data for emotion analysis. The input is the user's voice and video data, and the output is data converted into the format required for analysis. Specifically, the device sends the data acquired by the microphone and camera to the emotion analysis engine in real time.

[0433] Step 4:

[0434] The server receives the emotion data analyzed by the emotion analysis engine and uses it as data for generating daily reports. The input is the analyzed emotion data (e.g., "joy," "sadness," "anger"), and the output is daily report data that combines this emotion data with task information. Specifically, the server integrates the emotion data with task information and sends prompt sentences to the generative AI model.

[0435] Step 5:

[0436] The generative AI model generates daily reports based on prompts received from the server. The input is data (task information and emotion data) integrated with the prompt, and the output is the generated daily report text. Specifically, a prompt such as "Please generate a daily report based on today's work content and emotions" is input into the model, and the generated daily report text is obtained.

[0437] Step 6:

[0438] The server saves the generated daily report in a specified format (e.g., Markdown format, Excel format). The input is the generated daily report text, and the output is a daily report file saved in the specified file format. Specifically, the content of the daily report is converted to Markdown or Excel format and saved in the file system.

[0439] Step 7:

[0440] The server retrieves one week's worth of daily report data from the database and automatically generates a weekly report based on this. The input is the daily report data, and the output is the generated weekly report text. Specifically, the server aggregates the daily report data and sends a prompt message to the generative AI model saying, "Please generate a weekly report based on the work content and emotions of the past week," to generate the weekly report.

[0441] Step 8:

[0442] The server saves the generated weekly report in a specified format. The input is the generated weekly report text, and the output is a weekly report file saved in a specified file format. Specifically, the contents of the weekly report are converted to Markdown or Excel format and saved in the file system.

[0443] (Application example 2)

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

[0445] In conventional factory environments, worker task management and progress reporting are often done manually, resulting in reduced efficiency. Furthermore, because the emotions and motivation of workers are not taken into account, this can have a negative impact on work efficiency and safety. Therefore, there is a need for a system that integrates task management and emotion recognition to provide efficient and comprehensive management.

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

[0447] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating a daily report based on the information in the database, means for saving the daily report in a predetermined format, means for acquiring a user's voice input or facial recognition data and analyzing their emotions, and means for adjusting the content of the daily report based on the emotion analysis results. This enables integrated management of the task progress and emotional state of workers, enabling efficient work instructions and appropriate motivation management.

[0448] An "external system" is a system that allows factory robots and workers to obtain information from task management tools, databases, etc.

[0449] "Task information" is information such as the name of the work to be performed in the factory, the person in charge, the status, the start date, and the end date.

[0450] A "database" is an information management system that stores acquired task information and facilitates search and extraction.

[0451] A "daily report" is a report used to record and store the progress of work and emotional state of the day.

[0452] A "weekly report" is a report summarizing work progress and emotional state for a particular week.

[0453] "Emotion analysis" is the process of identifying and analyzing a user's emotional state based on their voice input and facial recognition data.

[0454] The "emotion engine" is a software component that analyzes voice input and facial recognition data to classify the user's emotions into categories such as "joy," "sadness," and "anger."

[0455] A "server" is a computer system that acquires data from external systems, stores it in a database, and generates and saves daily and weekly reports.

[0456] "Voice input" is an interface where a user provides data to a system using their voice.

[0457] "Facial recognition data" refers to image data of a user's face acquired using a device such as a camera.

[0458] The "prescribed format" refers to a standardized format in which daily and weekly reports are saved, such as Markdown format or Excel format.

[0459] MODE FOR CARRYING OUT THE INVENTION

[0460] The present invention is a system that integrates task management and emotion recognition for workers in a factory. Hereinafter, an embodiment of the present invention will be described in detail.

[0461] 1. Obtaining task information from an external system

[0462] The server sends a request to an external system (e.g., a task management tool) via an application programming interface (API) to obtain the required task information, including the task name, person in charge, status, start date, end date, etc. The obtained task information is stored in a database by the server.

[0463] 2. Storing task information in a database

[0464] The server stores the task information obtained from the external system in a database. This operation establishes data storage that can be quickly referenced in subsequent processes. In addition to task information, the database also stores worker emotion data.

[0465] 3. Emotion Recognition by Emotion Engine

[0466] The device receives voice input and facial recognition data from the user. This data is analyzed by an emotion engine, which classifies the user's emotions into categories such as "happiness," "sadness," and "anger." The analysis results are stored in a database and reflected in the content of daily and weekly reports.

[0467] 4. Generate daily reports

[0468] The server automatically generates daily reports for each worker based on task information retrieved from the database and the results of the emotion engine's analysis. The content of the daily reports is adjusted based on the results of the emotion analysis.

[0469] 5. Saving daily reports

[0470] The server saves the generated daily reports in a specified format (for example, Markdown or Excel format). This format ensures that the daily reports are stored in a unified format.

[0471] 6. Generate weekly reports

[0472] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database, and also takes into account the results of sentiment analysis.

[0473] 7. Saving weekly reports

[0474] The server saves the generated weekly reports in a specified format, which allows the weekly reports to be stored in a unified format.

[0475] A concrete example of how this system works is the process in which a factory worker uses a smartphone to input task progress and record their emotions through voice input. For example, the worker might say, "I'm glad that work went smoothly today." This voice data is analyzed by the emotion engine and recognized as "joy." As a result, the server automatically generates a daily report based on this information, such as, "Work went smoothly today. I'm satisfied," and saves it in a specified format.

[0476] The specific hardware used includes smartphones and factory robots, the software uses Python and SQLite, and retrieves data from external systems via APIs, and an emotion engine is used for emotion analysis.

[0477] Further examples of leveraging generative AI models include prompts such as:

[0478] One day, you have to create a system for reporting work at a factory. Write a program that retrieves task information from an external task management tool, stores it in a database, and generates daily and weekly reports. You also need to incorporate a function to analyze user sentiment and reflect the results in the reports.

[0479] This type of structure allows for efficient work instructions, appropriate motivation management, and integrated task and emotion management.

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

[0481] Step 1:

[0482] Retrieving task information from an external system

[0483] The server sends an API request to an external system (such as a task management tool) to obtain the required task information. As input, the request data for the task information to be obtained (e.g., project ID and authentication information) is provided. As output, the obtained task information (e.g., task name, assignee, status, start date, end date) is obtained. This task information is passed to the server in JSON format. The server stores this information in temporary memory.

[0484] Step 2:

[0485] Storing task information in a database

[0486] The server stores the retrieved task information in a database. The task information retrieved in step 1 is used as input. The server inserts the task information into the database using an SQL query. The output is confirmation of the newly added task information in the database. This establishes data storage that can be quickly referenced in subsequent processes.

[0487] Step 3:

[0488] Emotion recognition by emotion engine

[0489] The device receives voice input or facial recognition data from the user. Inputs include voice data and camera image data provided by the user to the device. The device sends this data to the emotion engine, which analyzes the emotions. The output is analyzed emotion data (e.g., "joy," "sadness," "anger," etc.). The analyzed emotion data is registered in a database. This information is used when generating daily reports.

[0490] Step 4:

[0491] Generate daily reports

[0492] The server retrieves task information and the emotion engine's analysis results from the database and automatically generates daily reports for each user. The user's task information and emotion data are retrieved from the database as input. The server creates the text content of the daily report based on this data. The generated text data of the daily report is obtained as output. This text data is used in subsequent processing.

[0493] Step 5:

[0494] Saving daily reports

[0495] The server saves the generated daily report in a specified format (Markdown or Excel format). The input is the text data of the generated daily report. The server uses a file manipulation library to save the file in the specified format. As an output, the daily report file is saved in a specified folder. This file is referenced later.

[0496] Step 6:

[0497] Generate weekly reports

[0498] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. Daily report information for a specified week is retrieved from the database as input. The server creates the text content of the weekly report based on this data. The output is the text data of the generated weekly report.

[0499] Step 7:

[0500] Saving weekly reports

[0501] The server saves the generated weekly report in a specified format. The input is the text data of the generated weekly report. The server uses a file operation library to save the file in the specified format. As an output, the weekly report file is saved in a specified folder. This file is referenced later.

[0502] In this way, daily and weekly reports based on task information and emotion data are efficiently generated and stored.

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

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

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

[0506] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0519] The present invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[0520] 1. Obtaining task information from an external system

[0521] The server sends a request to an external system (e.g., a project management tool or task management tool) via API to obtain the necessary task information, including the task name, assignee, status, start date, end date, etc.

[0522] Natural language explanations

[0523] The server sends API requests to external systems to retrieve information about projects and tasks, including task names, assignees, statuses, start and end dates, and so on, and stores this data in a database.

[0524] Specific examples

[0525] For example, when the server retrieves task information for "Project ABC" from a project management tool, it sends an API request and receives task information in response, including the task name "Design Review," the person in charge "Yamada Taro," the status "In Progress," the start date "2023-10-01," and the end date "2023-10-05."

[0526] 2. Store task information in a database

[0527] The server stores the acquired task information in a database, allowing the data required for subsequent processing to be quickly referenced.

[0528] Natural language explanations

[0529] The server stores the task information obtained from the external system in a database, which is used to generate future daily and weekly reports.

[0530] Specific examples

[0531] If the task information obtained from the project management tool is a "design review" task, save this information to the database. The fields saved in the database include the task ID, name, assignee, status, time log, etc.

[0532] 3. Generate daily reports

[0533] The server automatically generates daily reports for each employee based on task information retrieved from the database, detailing the work and progress of that day.

[0534] Natural language explanations

[0535] The server automatically generates daily reports for each employee based on task information in the database. The daily reports contain detailed information about the work done that day and the progress made, allowing employees to submit reports of a consistent quality without any effort.

[0536] Specific examples

[0537] For example, when generating a daily report for employee "Yamada Taro," the server automatically creates the report based on the task information for that day (e.g., task name "Design Review," status "Complete"). The daily report will include information such as "Today's Task: Design Review, Status: Completed, Work Time: 5 hours."

[0538] 4. Generate weekly reports

[0539] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. This weekly report is used to grasp the overall progress of the project.

[0540] Natural language explanations

[0541] The server automatically generates a weekly report summarizing the progress of a specific week based on the daily report data, allowing the progress of the entire project to be grasped at a glance.

[0542] Specific examples

[0543] For example, to check weekly progress, the server aggregates the daily report data in the database and generates a weekly report that includes information such as "Weekly tasks: Design review, Project ABC, Number of completed tasks: 5, Number of remaining tasks: 2."

[0544] 5. Saving the report

[0545] The server saves the generated daily and weekly reports in a specified format. Based on this format, the reports are saved in a unified format, making them easy for readers to understand.

[0546] Natural language explanations

[0547] The server stores automatically generated daily and weekly reports in a specified format, which allows the reports to be presented in a standardized format that is easy for readers to understand.

[0548] Specific examples

[0549] For example, when saving a daily report generated by the server, it saves it to a file in a specific format (e.g., Markdown or Excel format). This file is saved in a format such as "2023-10-05_Yamada Taro_DailyReport.md."

[0550] As described above, the system of the present invention can streamline and standardize work reporting and progress management by acquiring data from external systems, storing it in a database, automatically generating daily and weekly reports, and saving the reports in a specified format. This significantly reduces the workload of employees and improves the performance of the entire company.

[0551] The processing flow will be explained below.

[0552] Step 1:

[0553] The server sends a request to the API endpoint of the external system to obtain the required task information.

[0554] Specific actions

[0555] The server configures the API endpoint of the external system, along with the necessary query parameters and authentication information, and sends an API request to retrieve project and task information (e.g., task name, assignee, status, start date, end date, etc.).

[0556] python

[0557] url = "https: / / external-system.com / api / tasks"

[0558] params = {'project_id': 'ABC123'}

[0559] headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}

[0560] response = requests.get(url, params=params, headers=headers)

[0561] Step 2:

[0562] The server analyzes the response received from the external system and extracts the required information.

[0563] Specific actions

[0564] The server parses the API response in JSON format and extracts the required fields (e.g. task ID, name, assignee, status, time log, etc.) This data is either kept temporarily in memory for further processing or stored immediately in a database.

[0565] python

[0566] if response.status_code == 200:

[0567] tasks = response.json()

[0568] for task in tasks:

[0569] task_id = task['id']

[0570] task_name = task['name']

[0571] assignee = task['assignee']

[0572] status = task['status']

[0573] Processing to save to the database

[0574] Step 3:

[0575] The server stores the analyzed task information in a database.

[0576] Specific actions

[0577] The server saves the extracted task information to the appropriate table in the database by inserting each field (task ID, name, assignee, status, time log, etc.) into the corresponding column in the database.

[0578] python

[0579] def save_to_database(task):

[0580] connection = get_database_connection()

[0581] cursor = connection.cursor()

[0582] insert_query = """INSERT INTO tasks (task_id, name, assignee, status, time_log) VALUES (%s, %s, %s, %s, %s)"""

[0583] cursor.execute(insert_query, (task['id'], task['name'], task['assignee'], task['status'], task['time_log']))

[0584] connection.commit()

[0585] cursor.close()

[0586] connection.close()

[0587] Step 4:

[0588] The server retrieves task information for each employee from the database and generates a daily report.

[0589] Specific actions

[0590] The server queries the database for task information for each employee and automatically generates daily reports based on that information, including task name, person in charge, status, and work time.

[0591] python

[0592] employee_id = "yamada_taro"

[0593] jira_tickets = get_jira_tickets(employee_id)

[0594] confluence_updates = get_confluence_updates(employee_id)

[0595] commits = get_commit_history(employee_id)

[0596] daily_report = f"""

[0597] Daily report for {datetime.now().date()}

[0598] JIRA Tickets

[0599] {jira_tickets}

[0600] Confluence Update History

[0601] {confluence_updates}

[0602] Commit History

[0603] {commits}

[0604] """

[0605] Step 5:

[0606] The server saves the generated daily report in a specified format.

[0607] Specific actions

[0608] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format). This operation ensures that the daily reports are stored in a unified format, making them easier to refer to later.

[0609] python

[0610] with open(f" / path / to / reports / {employee_id}_daily_report.txt", "w") as file:

[0611] file.write(daily_report)

[0612] Step 6:

[0613] The server automatically generates a weekly report based on the daily report.

[0614] Specific actions

[0615] The server aggregates the daily report data stored in the database and generates a weekly report that reflects the progress for one week. The weekly report includes the progress of each task, the number of completed tasks, and the number of uncompleted tasks.

[0616] python

[0617] week_start = "2023-10-01"

[0618] week_end = "2023-10-07"

[0619] weekly_reports = get_weekly_reports(week_start, week_end)

[0620] weekly_report = f"""

[0621] Weekly report from {week_start} to {week_end}

[0622] {weekly_reports}

[0623] """

[0624] Step 7:

[0625] The server saves the generated weekly report in a specified format.

[0626] Specific actions

[0627] The server saves the generated weekly reports in a specific folder in a specified format. This operation ensures that the weekly reports are stored in a standardized format, making it easier to manage the progress of the entire project.

[0628] python

[0629] with open(" / path / to / reports / weekly_report.txt", "w") as file:

[0630] file.write(weekly_report)

[0631] The above are the specific processing steps of the present invention. Through each step, daily and weekly reports can be automatically generated efficiently and in a unified format, reducing the workload of employees and improving the efficiency of company-wide progress management.

[0632] Example 1

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

[0634] Conventional task management systems require the manual collection and organization of diverse project and task information, resulting in workload burdens and a high likelihood of management errors. Handling and recording information, especially when creating daily and weekly reports, takes time and effort. In addition, inconsistent formats can make reports difficult for readers to understand. There is a need to solve these problems and achieve efficient, standardized task management and report creation.

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

[0636] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating a daily report based on the information in the database, means for saving the daily report in a predetermined format, and means for creating a weekly report, thereby enabling automatic acquisition of task information and efficient storage in the database, as well as automatic generation and saving of standardized daily and weekly reports.

[0637] "External system" refers to a system that manages and provides task information, and includes software such as project management tools and task management tools.

[0638] "Task information" is detailed information about a project or work unit, including the task name, person in charge, status, start date, and end date.

[0639] "Database" refers to an information storage system that stores acquired task information and allows for quick reference in subsequent processing.

[0640] A "daily report" is a report that details the progress and work content of tasks on a specific day.

[0641] A "weekly report" is a report that summarizes the progress of tasks for the week and helps you understand the progress of the entire project.

[0642] An "application programming interface (API)" refers to an interface for exchanging data between different software programs.

[0643] An "authentication token" is security information used when sending an API request to verify that the request is legitimate.

[0644] "JSON format" is an abbreviation for JavaScript Object Notation, and is a lightweight data exchange format for expressing data structures in text format.

[0645] "SQL statement" stands for Structured Query Language and is an instruction for interacting with a database management system.

[0646] A "template engine" is a software component that embeds dynamic data into standard text and is used to automatically generate reports.

[0647] The Markdown format is a lightweight markup language for writing plain text, and is a format that pursues ease of reading and writing.

[0648] "Excel format" is a file format used by Microsoft Excel, a spreadsheet software, for organizing data and performing calculations.

[0649] The present invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[0650] Retrieving task information from an external system

[0651] The server sends a request to an external system (e.g., a project management tool or task management tool) via API to obtain the required task information. To do this, the server uses a pre-prepared URL and authentication token. The obtained task information is then parsed in JSON format. Task information includes the task name, assignee, status, start date, end date, etc.

[0652] Specific examples

[0653] For example, when a server retrieves task information for "Project XYZ" from a project management tool, it sends an API request and receives task information in response, including the task name "Design Review," the assignee "Ichiro Sato," the status "In Progress," the start date "2023-11-01," and the end date "2023-11-05."

[0654] Store task information in a database

[0655] The server converts the acquired task information into SQL statements and stores them in a database. The database is SQL-based and saves the information in a format that corresponds to each field (task ID, name, person in charge, status, start date, end date, etc.).

[0656] Specific examples

[0657] After retrieving the "Design Review" task from the project management tool, save this information to the database using the SQL statement "INSERT INTO tasks (task_id, name, status, start_date, end_date) VALUES (1, 'Design Review', 'In Progress', '2023-11-01', '2023-11-05')".

[0658] Generate daily reports

[0659] The server automatically generates daily reports for each employee based on task information retrieved from the database. Daily reports are created using a template engine (e.g., Jinja2) and include detailed information about the work and progress of that day.

[0660] Specific examples

[0661] For example, when generating a daily report for employee "Ichiro Sato," the server automatically creates the report based on the task information for that day (e.g., task name "Design Review," status "Complete"), and uses a template to generate a daily report with content such as "Today's Task: Design Review, Status: Completed, Work Time: 5 hours."

[0662] Generate weekly reports

[0663] The server automatically generates weekly reports summarizing progress on a weekly basis based on the daily report data. Weekly reports are also created using a template engine.

[0664] Specific examples

[0665] For example, to see progress for a particular week, the server aggregates the daily report data and generates a weekly report that might include something like "Weekly tasks: Design Review, Project XYZ, Number of completed tasks: 5, Number of remaining tasks: 2."

[0666] Save the report

[0667] The server saves the generated daily and weekly reports in a specified format, such as Markdown or Excel. The saved reports are managed in a specific directory.

[0668] Specific examples

[0669] For example, files will be saved in formats such as "2023-11-05_Sato Ichiro_DailyReport.md" or "2023-W45_WeeklyReport.xlsx".

[0670] As described above, the system of the present invention can streamline and standardize work reports and progress management by acquiring data from external systems, storing it in a database, automatically generating daily and weekly reports, and saving the reports in a specified format. This is expected to significantly reduce the workload of employees and improve the performance of the entire company.

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

[0672] Step 1:

[0673] Retrieving task information from an external system

[0674] The server sends an API request to the external system to obtain the required task information. To do this, the server sends an HTTP GET request including a previously prepared URL and authentication token. The input required is the API endpoint of the external system and the authentication token. The output is the task information in JSON format, which is returned as a response. Specifically, the server constructs an HTTP request including the authentication token in the header and sends it to the API endpoint. The response is then parsed to extract the required task information.

[0675] Step 2:

[0676] Parsing task information and storing it in a database

[0677] The server parses the acquired JSON formatted task information and stores it in the database. The JSON data acquired in step 1 is required as input. The output is the task information stored in the database. Specifically, the server parses the acquired JSON data and extracts each field (task ID, name, assignee, status, start date, end date, etc.). It then generates an SQL statement and executes the INSERT statement on the database.

[0678] Step 3:

[0679] Generate daily reports

[0680] The server retrieves task information from the database and automatically generates daily reports for each employee. The input requires task information stored in the database. The output is the automatically generated daily report. Specifically, the server uses an SQL SELECT statement to retrieve task information for a specific employee from the database. It then uses a template engine (e.g., Jinja2) to embed the information in a template and generate the daily report.

[0681] Step 4:

[0682] Generate weekly reports

[0683] The server automatically generates weekly reports based on daily reports. The input requires daily report data from the database. The output is the generated weekly report. Specifically, the server uses an SQL SELECT statement to retrieve daily report data within a specific week range. It then aggregates this daily report data and generates the weekly report using a template engine.

[0684] Step 5:

[0685] Save the report

[0686] The server saves the generated daily and weekly reports in a specified format (Markdown or Excel). The automatically generated daily and weekly reports are required as input. The output is a file saved in the specified format. Specifically, the server uses a template engine to convert the generated report into a Markdown or Excel file and saves it in a specified directory. For example, the file is saved in a format such as "2023-11-05_EmployeeA_DailyReport.md" or "2023-W45_WeeklyReport.xlsx."

[0687] (Application example 1)

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

[0689] With conventional factory task management systems, it was difficult to accurately grasp the work progress of each robot and automatically generate daily and weekly reports. Furthermore, checking the progress of tasks performed by individual robots required a lot of manual work, which was inefficient and prone to information being lost. This resulted in a decline in overall productivity and made it difficult to share information in a timely manner.

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

[0691] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating daily reports based on the information in the database, means for saving the daily reports in a predetermined format, means for acquiring task information from a robot control system, storing the task information in a database, and saving daily and weekly reports automatically generated based on the robot's work progress, and means for checking the task progress status for a specified period using a generative AI model. This makes it possible to efficiently manage the robot's work progress and automatically generate and save daily and weekly reports.

[0692] An "external system" is an information system that provides task information from data outside the factory, project management tools, etc.

[0693] "Task information" is data consisting of information such as specific work content, person in charge, status, start date, and end date.

[0694] A "database" is a structured data storage system that stores acquired task information and allows quick reference as needed.

[0695] A "daily report" is a report detailing the work and progress of each robot on a particular day.

[0696] A "weekly report" is a report summarizing the progress of work during a particular week.

[0697] A "robot control system" is a system for managing and controlling the operation of robots within a factory.

[0698] A "generative AI model" is an artificial intelligence algorithm that identifies and analyzes task progress over a specified period of time.

[0699] A "prescribed format" is a document format that is established so that reports are saved in a unified format and are easy for readers to understand.

[0700] This invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is realized through the cooperation of a server, terminals, and users.

[0701] 1. Obtaining task information from an external system

[0702] The server sends a request via API to an external system (for example, an external data or project management tool) to obtain the required task information. Task information includes the task name, person in charge, status, start date, and end date. Specifically, the server uses the API of the factory's robot control system to obtain the work progress of each robot. This information includes the work content, the robot responsible for the work, the progress status, and the start and end dates.

[0703] 2. Store task information in a database

[0704] The server stores the acquired task information in a database, allowing for quick reference of the data required for subsequent processing. The database is configured using SQLite and stores detailed data for each task.

[0705] 3. Generate daily reports

[0706] The server automatically generates a daily report for each robot based on task information retrieved from the database. This daily report contains detailed information about the work and progress of that day. Specifically, the server extracts information about tasks performed on a specific day and automatically creates a daily report.

[0707] 4. Generate weekly reports

[0708] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. This allows you to grasp the overall progress status. The server aggregates the weekly task data and compiles it into a weekly report.

[0709] 5. Saving the report

[0710] The server saves the generated daily and weekly reports in a specified format. Based on this format, the reports are saved in a unified format, making them easy for readers to understand. For example, Markdown or Excel is used as the saving format.

[0711] 6. Leveraging generative AI models

[0712] The server uses the generative AI model to check the progress of a task over a specified period, allowing users to view the progress and time spent on a specific task through prompts.

[0713] For example, use the following prompt:

[0714] "I would like to check the progress of a specific task. Please let me know whether Robot A has completed the 'Parts assembly' task and how long it took between the start dates of 2023-10-01 and 2023-10-07."

[0715] With the above functions, the present invention can efficiently manage the work progress of robots in a factory and automatically generate and save daily and weekly reports.

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

[0717] Step 1:

[0718] The server obtains task information from an external system. Specifically, it sends an API request and receives task information as a response. The input is the API endpoint and authentication information of the external system, and the output is task information including the task name, person in charge, status, start date, and end date. For example, the API of a robot control system is used to obtain data on the work performed by a specific robot.

[0719] Step 2:

[0720] The server stores the acquired task information in the database. Specifically, it executes an INSERT query on the SQLite database. The input is the task information acquired in step 1, and the output is the task information stored in the database. This means that detailed data of each task (such as name, assignee, progress status, etc.) is accurately stored in the database.

[0721] Step 3:

[0722] The server automatically generates daily reports based on task information retrieved from the database. Specifically, it extracts task data related to a specific date using an SQL query and embeds it in a template. A specific date is specified as input, and the output is a daily report text that describes the work and progress of that day. For example, it generates a daily report that includes information that the "design review" task was completed that day.

[0723] Step 4:

[0724] The server automatically generates weekly reports based on the daily report information stored in the database. Specifically, it aggregates the daily report data for a specified week and embeds it back into the template. The input is the start and end dates, and the output is a weekly report text summarizing the progress for the week. For example, a weekly report can be generated that displays the number of tasks completed and the number of tasks remaining in a specific week.

[0725] Step 5:

[0726] The server saves the generated daily and weekly reports in a specified format. Specifically, the generated report text data is saved as a file in Markdown or Excel format. The input is the report text data, and the output is a file in the specified format. For example, the report is saved with a file name such as "2023-10-05_dailyreport.md".

[0727] Step 6:

[0728] The server uses the generative AI model to check the task progress for a specified period. Specifically, it analyzes the prompt text entered by the user, extracts the corresponding task data from the database, and processes it. The input is the prompt text entered by the user, and the output is the analysis results regarding the progress and work time within the specified period. For example, it can check progress such as "Has Robot A completed the 'assembly of parts' task?"

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

[0730] This invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information, in addition to combining it with an emotion engine that recognizes the user's emotions. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[0731] 1. Obtaining task information from an external system

[0732] The server sends a request via API to an external system (e.g., a project management tool or task management tool) to retrieve the required task information, including the task name, assignee, status, start date, end date, etc.

[0733] Natural language explanations

[0734] The server sends API requests to external systems to retrieve information about projects and tasks, which is then stored in a database.

[0735] Specific examples

[0736] For example, when a server retrieves task information for "Project ABC" from a project management tool, it sends an API request and receives task information (e.g., task name "Design Review," task owner "Yamada Taro," status "In Progress," etc.) in response.

[0737] 2. Store task information in a database

[0738] The server stores the acquired task information in a database, allowing the data required for subsequent processing to be quickly referenced.

[0739] Natural language explanations

[0740] The server stores task information obtained from external systems in a database. The saved data is used to generate daily and weekly reports.

[0741] Specific examples

[0742] The acquired task information (e.g., task name "Design Review", task owner "Yamada Taro", status "In Progress", start date "2023-10-01", end date "2023-10-05", etc.) is saved in the database.

[0743] 3. Emotion Recognition by Emotion Engine

[0744] The device receives voice input and facial recognition data from the user and analyzes the user's emotions using an emotion engine.

[0745] Natural language explanations

[0746] The device uses an emotion engine to analyze the user's emotions based on the user's voice input and facial recognition data obtained from camera footage. The analysis results influence the generation of subsequent daily reports.

[0747] Specific examples

[0748] When a user inputs voice into the device, the device sends the voice to the emotion engine, which analyzes the voice and recognizes emotions such as "joy," "sadness," and "anger."

[0749] 4. Generate daily reports

[0750] The server automatically generates daily reports for each employee based on task information retrieved from the database and the results of the emotion engine's analysis. The content of the daily reports is adjusted based on the results of the emotion analysis.

[0751] Natural language explanations

[0752] The server automatically generates the contents of the daily report based on the task information in the database and the results of emotion analysis, so that the user's mood and emotions are reflected in the daily report.

[0753] Specific examples

[0754] When generating a daily report for user "Yamada Taro," the server generates a daily report with content such as "Today, we progressed with the design review. It is progressing smoothly and I am very satisfied." based on task information (e.g., "Design review, in progress, 5 hours of work") and emotion analysis results (e.g., "Delighted").

[0755] 5. Saving daily reports

[0756] The server saves the generated daily reports in a predetermined format, which allows the daily reports to be saved in a unified format.

[0757] Natural language explanations

[0758] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format), so that the daily reports are stored in a unified format.

[0759] Specific examples

[0760] Save the generated daily report in a format such as "2023-10-05_Yamada Taro_DailyReport.md".

[0761] 6. Generate weekly reports

[0762] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database, and also takes into account the results of sentiment analysis.

[0763] Natural language explanations

[0764] The server automatically generates a weekly report summarizing the progress of a specific week based on the daily report data. The results of sentiment analysis are also reflected in the weekly report.

[0765] Specific examples

[0766] A weekly report is generated based on task information for the specified week (e.g., "5 completed tasks, 2 incomplete tasks") and sentiment analysis results (e.g., "Overall satisfaction was high this week").

[0767] 7. Saving weekly reports

[0768] The server saves the generated weekly reports in a predetermined format, which allows the weekly reports to be saved in a unified format.

[0769] Natural language explanations

[0770] The server saves the generated weekly reports in a specific folder in a specified format, so that the weekly reports are stored in a unified format.

[0771] Specific examples

[0772] Save the generated weekly report in the format "2023-10-01_To_2023-10-07_WeeklyReport.md".

[0773] The above is a specific embodiment of the present invention. By combining it with an emotion engine, it is possible to realize an advanced reporting system that not only manages tasks and reports progress, but also takes into account the emotions of users. This allows reports to be created that reflect the moods and motivations of employees, which is expected to improve the performance of the entire company.

[0774] The processing flow will be explained below.

[0775] Step 1:

[0776] The server sends a request to the API endpoint of the external system to obtain the required task information.

[0777] Specific actions

[0778] The server configures the API endpoint of the external system, along with the necessary query parameters and authentication information, and sends an API request to retrieve project and task information (e.g., task name, assignee, status, start date, end date, etc.).

[0779] python

[0780] url = "https: / / external-system.com / api / tasks"

[0781] params = {'project_id': 'ABC123'}

[0782] headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}

[0783] response = requests.get(url, params=params, headers=headers)

[0784] Step 2:

[0785] The server analyzes the response received from the external system and extracts the required information.

[0786] Specific actions

[0787] The server parses the API response in JSON format and extracts the required fields (e.g. task ID, name, assignee, status, time log, etc.) This data is either kept temporarily in memory for further processing or stored immediately in a database.

[0788] python

[0789] if response.status_code == 200:

[0790] tasks = response.json()

[0791] for task in tasks:

[0792] task_id = task['id']

[0793] task_name = task['name']

[0794] assignee = task['assignee']

[0795] status = task['status']

[0796] Processing to save to the database

[0797] Step 3:

[0798] The server stores the analyzed task information in a database.

[0799] Specific actions

[0800] The server saves the extracted task information to the appropriate table in the database by inserting each field (task ID, name, assignee, status, time log, etc.) into the corresponding column in the database.

[0801] python

[0802] def save_to_database(task):

[0803] connection = get_database_connection()

[0804] cursor = connection.cursor()

[0805] insert_query = """INSERT INTO tasks (task_id, name, assignee, status, time_log) VALUES (%s, %s, %s, %s, %s)"""

[0806] cursor.execute(insert_query, (task['id'], task['name'], task['assignee'], task['status'], task['time_log']))

[0807] connection.commit()

[0808] cursor.close()

[0809] connection.close()

[0810] Step 4:

[0811] The device receives the user's voice input and camera footage and sends them to an emotion recognition engine.

[0812] Specific actions

[0813] The device receives voice input from the user and camera footage in real time and sends the voice and image data to the emotion recognition engine.

[0814] python

[0815] def capture_user_input():

[0816] audio_data = record_audio()

[0817] video_data = capture_video()

[0818] return audio_data, video_data

[0819] Step 5:

[0820] The emotion recognition engine analyzes voice input and camera footage to recognize the user's emotions.

[0821] Specific actions

[0822] The emotion recognition engine analyzes the acquired voice and image data to recognize the user's emotions (e.g., joy, sadness, anger, etc.). The analysis results are sent to the server.

[0823] python

[0824] def analyze_emotion(audio_data, video_data):

[0825] emotion_results = emotion_engine.process(audio_data, video_data)

[0826] return emotion_results

[0827] Step 6:

[0828] The server stores the emotion recognition results in a database.

[0829] Specific actions

[0830] The server stores the analysis results (e.g., type and intensity of emotion) received from the emotion recognition engine in an appropriate table in the database.

[0831] python

[0832] def save_emotion_to_database(employee_id, emotion_results):

[0833] connection = get_database_connection()

[0834] cursor = connection.cursor()

[0835] insert_query = """INSERT INTO emotions (employee_id, emotion, intensity) VALUES (%s, %s, %s)"""

[0836] cursor.execute(insert_query, (employee_id, emotion_results['emotion'], emotion_results['intensity']))

[0837] connection.commit()

[0838] cursor.close()

[0839] connection.close()

[0840] Step 7:

[0841] The server retrieves task information and emotion recognition results for each employee from the database and generates a daily report.

[0842] Specific actions

[0843] The server issues a query to retrieve task information and emotion recognition results from the database for each employee, and automatically generates a daily report based on that information. The generated report includes information such as task name, person in charge, status, working time, and type and intensity of emotion.

[0844] python

[0845] employee_id = "yamada_taro"

[0846] tasks = get_tasks(employee_id)

[0847] emotions = get_emotions(employee_id)

[0848] daily_report = f"""

[0849] Daily report for {datetime.now().date()}

[0850] task

[0851] {tasks}

[0852] emotions

[0853] {emotions}

[0854] """

[0855] Step 8:

[0856] The server saves the generated daily report in a specified format.

[0857] Specific actions

[0858] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format). This operation ensures that the daily reports are stored in a unified format, making them easier to refer to later.

[0859] python

[0860] with open(f" / path / to / reports / {employee_id}_daily_report.txt", "w") as file:

[0861] file.write(daily_report)

[0862] Step 9:

[0863] The server automatically generates a weekly report based on the daily report.

[0864] Specific actions

[0865] The server aggregates the daily report data stored in the database and generates a weekly report that reflects the progress and sentiment analysis results for the week. The weekly report includes the progress of each task, the number of completed tasks, the number of incomplete tasks, and an overview of the user's sentiment.

[0866] python

[0867] week_start = "2023-10-01"

[0868] week_end = "2023-10-07"

[0869] weekly_reports = get_weekly_reports(week_start, week_end)

[0870] weekly_report = f"""

[0871] Weekly report from {week_start} to {week_end}

[0872] {weekly_reports}

[0873] """

[0874] Step 10:

[0875] The server saves the generated weekly report in a specified format.

[0876] Specific actions

[0877] The server saves the generated weekly reports in a specific folder in a specified format. This operation ensures that the weekly reports are stored in a standardized format, making it easier to manage the progress of the entire project.

[0878] python

[0879] with open(" / path / to / reports / weekly_report.txt", "w") as file:

[0880] file.write(weekly_report)

[0881] These are the specific processing steps of the present invention. By combining it with an emotion engine, it is possible to realize an advanced reporting system that not only manages tasks and reports progress, but also takes into account the emotions of users. This allows reports to be created that reflect the moods and motivations of employees, which is expected to improve the performance of the entire company.

[0882] Example 2

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

[0884] In today's work environment, task management and progress reporting are important, but one-way reporting systems that don't take into account employee emotions and motivation have limitations in improving work efficiency and employee satisfaction. Furthermore, manually creating daily and weekly reports is time-consuming and labor-intensive, making them inefficient. To solve these problems, a reporting system that combines automatic task information acquisition and emotion analysis is needed.

[0885] 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 acquiring task information from an external system, a means for storing the acquired task information in a database, a sentiment analysis means for analyzing the user's sentiment, a means for creating a daily report based on the information in the database and the sentiment analysis results, and a means for saving the daily report in a predetermined format. This makes it possible to automatically generate a report that integrates task information and sentiment information, thereby realizing advanced task management and progress reporting that reflects the sentiments of employees.

[0886] An "external system" is a system that provides task information, such as a project management tool or a task management tool.

[0887] "Task information" is a series of information about a task, such as the task name, person in charge, status, start date, and end date.

[0888] A "database" is a data storage system that stores acquired task information and enables quick reference to data required for subsequent processing.

[0889] The "emotion analysis means" is a system that analyzes the user's voice input and facial recognition data, and identifies the user's emotions as labels such as "joy," "sadness," and "anger."

[0890] A "daily report" is a report summarizing daily work and progress based on database information and sentiment analysis results.

[0891] A "weekly report" is a report that summarizes progress on a weekly basis based on daily reports.

[0892] A "prescribed format" is a standardized file format that ensures reports are saved in a consistent format, including Markdown and Excel formats.

[0893] This invention is a system that acquires task information from an external system, stores it in a database, and then analyzes user emotions to automatically generate daily and weekly reports. This system is implemented mainly with the cooperation of a server, terminals, and users.

[0894] Hardware and Software Configuration

[0895] The server connects to external systems via an application programming interface (API) for communicating with project management tools and task management tools. The server also requires a database connection driver such as ODBC or JDBC to store the acquired task information in a database. Programming languages ​​and libraries such as Python or Java are also used to generate daily and weekly reports using sentiment analysis and generative AI models.

[0896] The device has hardware and software to capture user voice input and camera footage and send it to an emotion analysis engine, including a microphone, camera, and voice and facial recognition software.

[0897] The user uses a terminal to input data (audio, video, etc.) for the daily report. The audio and video data input by the user is sent to the emotion analysis engine via the terminal.

[0898] Specific operation of the system

[0899] 1. Get task information

[0900] The server sends an HTTP request to the API of the external system to obtain task information. The obtained information is received in JSON format and parsed. For example, obtain task information for "Project XYZ" from a project management tool.

[0901] 2. Storage in the database

[0902] The server uses SQL INSERT and UPDATE statements to store the retrieved task information in the database, so that the task information is saved in the database and can be quickly referenced at any time.

[0903] 3. Emotion analysis

[0904] The device receives voice input and camera footage from the user and sends it to an emotion analysis engine. The analysis engine analyzes the audio and video data and identifies the user's emotion as a label such as "happiness," "sadness," or "anger." For example, if a user says to the device, "Today's meeting was very constructive," the emotion engine will interpret it as "happiness."

[0905] 4. Generate daily and weekly reports

[0906] The server generates a daily report based on task information retrieved from the database and the results of sentiment analysis. A generative AI model is used in this process. A prompt such as "Please generate a daily report based on today's work content and emotions" is sent to the model. The generated daily report is saved in a specified format such as Markdown or Excel.

[0907] 5. Saving and Referencing

[0908] Daily reports are saved in a specific folder by the server, and weekly reports are saved in the same way. For example, the daily report is saved as "2023-10-05_EmployeeA_DailyReport.md" and the weekly report is saved as "2023-10-01_To_2023-10-07_WeeklyReport.md".

[0909] In this way, by automatically generating reports that integrate task information and emotional information, it is possible to achieve advanced task management and progress reports that reflect employees' emotions, enabling effective business operations that take into account employees' moods and motivations.

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

[0911] Step 1:

[0912] The server obtains task information from an external system. Specifically, the server sends an HTTP GET request to the external system's API and receives task information in JSON format. The input is the API request parameters (e.g., project ID), and the output is the JSON-formatted task information received as a response. The server parses this task information and extracts the necessary data items (e.g., task name, assignee, status, start date, and end date).

[0913] Step 2:

[0914] The server stores the extracted task information in a database. The input is the extracted task information, and the output is the newly added or updated data in the database. Specifically, the server generates SQL INSERT or UPDATE statements and executes them against the database via ODBC or JDBC. This saves the task information in the database.

[0915] Step 3:

[0916] The device receives voice input and camera footage from the user and prepares it as data for emotion analysis. The input is the user's voice and video data, and the output is data converted into the format required for analysis. Specifically, the device sends the data acquired by the microphone and camera to the emotion analysis engine in real time.

[0917] Step 4:

[0918] The server receives the emotion data analyzed by the emotion analysis engine and uses it as data for generating daily reports. The input is the analyzed emotion data (e.g., "joy," "sadness," "anger"), and the output is daily report data that combines this emotion data with task information. Specifically, the server integrates the emotion data with task information and sends prompt sentences to the generative AI model.

[0919] Step 5:

[0920] The generative AI model generates daily reports based on prompts received from the server. The input is data (task information and emotion data) integrated with the prompt, and the output is the generated daily report text. Specifically, a prompt such as "Please generate a daily report based on today's work content and emotions" is input into the model, and the generated daily report text is obtained.

[0921] Step 6:

[0922] The server saves the generated daily report in a specified format (e.g., Markdown format, Excel format). The input is the generated daily report text, and the output is a daily report file saved in the specified file format. Specifically, the content of the daily report is converted to Markdown or Excel format and saved in the file system.

[0923] Step 7:

[0924] The server retrieves one week's worth of daily report data from the database and automatically generates a weekly report based on this. The input is the daily report data, and the output is the generated weekly report text. Specifically, the server aggregates the daily report data and sends a prompt message to the generative AI model saying, "Please generate a weekly report based on the work content and emotions of the past week," to generate the weekly report.

[0925] Step 8:

[0926] The server saves the generated weekly report in a specified format. The input is the generated weekly report text, and the output is a weekly report file saved in a specified file format. Specifically, the contents of the weekly report are converted to Markdown or Excel format and saved in the file system.

[0927] (Application example 2)

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

[0929] In conventional factory environments, worker task management and progress reporting are often done manually, resulting in reduced efficiency. Furthermore, because the emotions and motivation of workers are not taken into account, this can have a negative impact on work efficiency and safety. Therefore, there is a need for a system that integrates task management and emotion recognition to provide efficient and comprehensive management.

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

[0931] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating a daily report based on the information in the database, means for saving the daily report in a predetermined format, means for acquiring a user's voice input or facial recognition data and analyzing their emotions, and means for adjusting the content of the daily report based on the emotion analysis results. This enables integrated management of the task progress and emotional state of workers, enabling efficient work instructions and appropriate motivation management.

[0932] An "external system" is a system that allows factory robots and workers to obtain information from task management tools, databases, etc.

[0933] "Task information" is information such as the name of the work to be performed in the factory, the person in charge, the status, the start date, and the end date.

[0934] A "database" is an information management system that stores acquired task information and facilitates search and extraction.

[0935] A "daily report" is a report used to record and store the progress of work and emotional state of the day.

[0936] A "weekly report" is a report summarizing work progress and emotional state for a particular week.

[0937] "Emotion analysis" is the process of identifying and analyzing a user's emotional state based on their voice input and facial recognition data.

[0938] The "emotion engine" is a software component that analyzes voice input and facial recognition data to classify the user's emotions into categories such as "joy," "sadness," and "anger."

[0939] A "server" is a computer system that acquires data from external systems, stores it in a database, and generates and saves daily and weekly reports.

[0940] "Voice input" is an interface where a user provides data to a system using their voice.

[0941] "Facial recognition data" refers to image data of a user's face acquired using a device such as a camera.

[0942] The "prescribed format" refers to a standardized format in which daily and weekly reports are saved, such as Markdown format or Excel format.

[0943] MODE FOR CARRYING OUT THE INVENTION

[0944] The present invention is a system that integrates task management and emotion recognition for workers in a factory. Hereinafter, an embodiment of the present invention will be described in detail.

[0945] 1. Obtaining task information from an external system

[0946] The server sends a request to an external system (e.g., a task management tool) via an application programming interface (API) to obtain the required task information, including the task name, person in charge, status, start date, end date, etc. The obtained task information is stored in a database by the server.

[0947] 2. Storing task information in a database

[0948] The server stores the task information obtained from the external system in a database. This operation establishes data storage that can be quickly referenced in subsequent processes. In addition to task information, the database also stores worker emotion data.

[0949] 3. Emotion Recognition by Emotion Engine

[0950] The device receives voice input and facial recognition data from the user. This data is analyzed by an emotion engine, which classifies the user's emotions into categories such as "happiness," "sadness," and "anger." The analysis results are stored in a database and reflected in the content of daily and weekly reports.

[0951] 4. Generate daily reports

[0952] The server automatically generates daily reports for each worker based on task information retrieved from the database and the results of the emotion engine's analysis. The content of the daily reports is adjusted based on the results of the emotion analysis.

[0953] 5. Saving daily reports

[0954] The server saves the generated daily reports in a specified format (for example, Markdown or Excel format). This format ensures that the daily reports are stored in a unified format.

[0955] 6. Generate weekly reports

[0956] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database, and also takes into account the results of sentiment analysis.

[0957] 7. Saving weekly reports

[0958] The server saves the generated weekly reports in a specified format, which allows the weekly reports to be stored in a unified format.

[0959] A concrete example of how this system works is the process in which a factory worker uses a smartphone to input task progress and record their emotions through voice input. For example, the worker might say, "I'm glad that work went smoothly today." This voice data is analyzed by the emotion engine and recognized as "joy." As a result, the server automatically generates a daily report based on this information, such as, "Work went smoothly today. I'm satisfied," and saves it in a specified format.

[0960] The specific hardware used includes smartphones and factory robots, the software uses Python and SQLite, and retrieves data from external systems via APIs, and an emotion engine is used for emotion analysis.

[0961] Further examples of leveraging generative AI models include prompts such as:

[0962] One day, you have to create a system for reporting work at a factory. Write a program that retrieves task information from an external task management tool, stores it in a database, and generates daily and weekly reports. You also need to incorporate a function to analyze user sentiment and reflect the results in the reports.

[0963] This type of structure allows for efficient work instructions, appropriate motivation management, and integrated task and emotion management.

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

[0965] Step 1:

[0966] Retrieving task information from an external system

[0967] The server sends an API request to an external system (such as a task management tool) to obtain the required task information. As input, the request data for the task information to be obtained (e.g., project ID and authentication information) is provided. As output, the obtained task information (e.g., task name, assignee, status, start date, end date) is obtained. This task information is passed to the server in JSON format. The server stores this information in temporary memory.

[0968] Step 2:

[0969] Storing task information in a database

[0970] The server stores the retrieved task information in a database. The task information retrieved in step 1 is used as input. The server inserts the task information into the database using an SQL query. The output is confirmation of the newly added task information in the database. This establishes data storage that can be quickly referenced in subsequent processes.

[0971] Step 3:

[0972] Emotion recognition by emotion engine

[0973] The device receives voice input or facial recognition data from the user. Inputs include voice data and camera image data provided by the user to the device. The device sends this data to the emotion engine, which analyzes the emotions. The output is analyzed emotion data (e.g., "joy," "sadness," "anger," etc.). The analyzed emotion data is registered in a database. This information is used when generating daily reports.

[0974] Step 4:

[0975] Generate daily reports

[0976] The server retrieves task information and the emotion engine's analysis results from the database and automatically generates daily reports for each user. The user's task information and emotion data are retrieved from the database as input. The server creates the text content of the daily report based on this data. The generated text data of the daily report is obtained as output. This text data is used in subsequent processing.

[0977] Step 5:

[0978] Saving daily reports

[0979] The server saves the generated daily report in a specified format (Markdown or Excel format). The input is the text data of the generated daily report. The server uses a file manipulation library to save the file in the specified format. As an output, the daily report file is saved in a specified folder. This file is referenced later.

[0980] Step 6:

[0981] Generate weekly reports

[0982] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. Daily report information for a specified week is retrieved from the database as input. The server creates the text content of the weekly report based on this data. The output is the text data of the generated weekly report.

[0983] Step 7:

[0984] Saving weekly reports

[0985] The server saves the generated weekly report in a specified format. The input is the text data of the generated weekly report. The server uses a file operation library to save the file in the specified format. As an output, the weekly report file is saved in a specified folder. This file is referenced later.

[0986] In this way, daily and weekly reports based on task information and emotion data are efficiently generated and stored.

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

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

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

[0990] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1003] The present invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[1004] 1. Obtaining task information from an external system

[1005] The server sends a request to an external system (e.g., a project management tool or task management tool) via API to obtain the necessary task information, including the task name, assignee, status, start date, end date, etc.

[1006] Natural language explanations

[1007] The server sends API requests to external systems to retrieve information about projects and tasks, including task names, assignees, statuses, start and end dates, and so on, and stores this data in a database.

[1008] Specific examples

[1009] For example, when the server retrieves task information for "Project ABC" from a project management tool, it sends an API request and receives task information in response, including the task name "Design Review," the person in charge "Yamada Taro," the status "In Progress," the start date "2023-10-01," and the end date "2023-10-05."

[1010] 2. Store task information in a database

[1011] The server stores the acquired task information in a database, allowing the data required for subsequent processing to be quickly referenced.

[1012] Natural language explanations

[1013] The server stores the task information obtained from the external system in a database, which is used to generate future daily and weekly reports.

[1014] Specific examples

[1015] If the task information obtained from the project management tool is a "design review" task, save this information to the database. The fields saved in the database include the task ID, name, assignee, status, time log, etc.

[1016] 3. Generate daily reports

[1017] The server automatically generates daily reports for each employee based on task information retrieved from the database, detailing the work and progress of that day.

[1018] Natural language explanations

[1019] The server automatically generates daily reports for each employee based on task information in the database. The daily reports contain detailed information about the work done that day and the progress made, allowing employees to submit reports of a consistent quality without any effort.

[1020] Specific examples

[1021] For example, when generating a daily report for employee "Yamada Taro," the server automatically creates the report based on the task information for that day (e.g., task name "Design Review," status "Complete"). The daily report will include information such as "Today's Task: Design Review, Status: Completed, Work Time: 5 hours."

[1022] 4. Generate weekly reports

[1023] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. This weekly report is used to grasp the overall progress of the project.

[1024] Natural language explanations

[1025] The server automatically generates a weekly report summarizing the progress of a specific week based on the daily report data, allowing the progress of the entire project to be grasped at a glance.

[1026] Specific examples

[1027] For example, to check weekly progress, the server aggregates the daily report data in the database and generates a weekly report that includes information such as "Weekly tasks: Design review, Project ABC, Number of completed tasks: 5, Number of remaining tasks: 2."

[1028] 5. Saving the report

[1029] The server saves the generated daily and weekly reports in a specified format. Based on this format, the reports are saved in a unified format, making them easy for readers to understand.

[1030] Natural language explanations

[1031] The server stores automatically generated daily and weekly reports in a specified format, which allows the reports to be presented in a standardized format that is easy for readers to understand.

[1032] Specific examples

[1033] For example, when saving a daily report generated by the server, it saves it to a file in a specific format (e.g., Markdown or Excel format). This file is saved in a format such as "2023-10-05_Yamada Taro_DailyReport.md."

[1034] As described above, the system of the present invention can streamline and standardize work reporting and progress management by acquiring data from external systems, storing it in a database, automatically generating daily and weekly reports, and saving the reports in a specified format. This significantly reduces the workload of employees and improves the performance of the entire company.

[1035] The processing flow will be explained below.

[1036] Step 1:

[1037] The server sends a request to the API endpoint of the external system to obtain the required task information.

[1038] Specific actions

[1039] The server configures the API endpoint of the external system, along with the necessary query parameters and authentication information, and sends an API request to retrieve project and task information (e.g., task name, assignee, status, start date, end date, etc.).

[1040] python

[1041] url = "https: / / external-system.com / api / tasks"

[1042] params = {'project_id': 'ABC123'}

[1043] headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}

[1044] response = requests.get(url, params=params, headers=headers)

[1045] Step 2:

[1046] The server analyzes the response received from the external system and extracts the required information.

[1047] Specific actions

[1048] The server parses the API response in JSON format and extracts the required fields (e.g. task ID, name, assignee, status, time log, etc.) This data is either kept temporarily in memory for further processing or stored immediately in a database.

[1049] python

[1050] if response.status_code == 200:

[1051] tasks = response.json()

[1052] for task in tasks:

[1053] task_id = task['id']

[1054] task_name = task['name']

[1055] assignee = task['assignee']

[1056] status = task['status']

[1057] Processing to save to the database

[1058] Step 3:

[1059] The server stores the analyzed task information in a database.

[1060] Specific actions

[1061] The server saves the extracted task information to the appropriate table in the database by inserting each field (task ID, name, assignee, status, time log, etc.) into the corresponding column in the database.

[1062] python

[1063] def save_to_database(task):

[1064] connection = get_database_connection()

[1065] cursor = connection.cursor()

[1066] insert_query = """INSERT INTO tasks (task_id, name, assignee, status, time_log) VALUES (%s, %s, %s, %s, %s)"""

[1067] cursor.execute(insert_query, (task['id'], task['name'], task['assignee'], task['status'], task['time_log']))

[1068] connection.commit()

[1069] cursor.close()

[1070] connection.close()

[1071] Step 4:

[1072] The server retrieves task information for each employee from the database and generates a daily report.

[1073] Specific actions

[1074] The server queries the database for task information for each employee and automatically generates daily reports based on that information, including task name, person in charge, status, and work time.

[1075] python

[1076] employee_id = "yamada_taro"

[1077] jira_tickets = get_jira_tickets(employee_id)

[1078] confluence_updates = get_confluence_updates(employee_id)

[1079] commits = get_commit_history(employee_id)

[1080] daily_report = f"""

[1081] Daily report for {datetime.now().date()}

[1082] JIRA Tickets

[1083] {jira_tickets}

[1084] Confluence Update History

[1085] {confluence_updates}

[1086] Commit History

[1087] {commits}

[1088] """

[1089] Step 5:

[1090] The server saves the generated daily report in a specified format.

[1091] Specific actions

[1092] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format). This operation ensures that the daily reports are stored in a unified format, making them easier to refer to later.

[1093] python

[1094] with open(f" / path / to / reports / {employee_id}_daily_report.txt", "w") as file:

[1095] file.write(daily_report)

[1096] Step 6:

[1097] The server automatically generates a weekly report based on the daily report.

[1098] Specific actions

[1099] The server aggregates the daily report data stored in the database and generates a weekly report that reflects the progress for one week. The weekly report includes the progress of each task, the number of completed tasks, and the number of uncompleted tasks.

[1100] python

[1101] week_start = "2023-10-01"

[1102] week_end = "2023-10-07"

[1103] weekly_reports = get_weekly_reports(week_start, week_end)

[1104] weekly_report = f"""

[1105] Weekly report from {week_start} to {week_end}

[1106] {weekly_reports}

[1107] """

[1108] Step 7:

[1109] The server saves the generated weekly report in a specified format.

[1110] Specific actions

[1111] The server saves the generated weekly reports in a specific folder in a specified format. This operation ensures that the weekly reports are stored in a standardized format, making it easier to manage the progress of the entire project.

[1112] python

[1113] with open(" / path / to / reports / weekly_report.txt", "w") as file:

[1114] file.write(weekly_report)

[1115] The above are the specific processing steps of the present invention. Through each step, daily and weekly reports can be automatically generated efficiently and in a unified format, reducing the workload of employees and improving the efficiency of company-wide progress management.

[1116] Example 1

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

[1118] Conventional task management systems require the manual collection and organization of diverse project and task information, resulting in workload burdens and a high likelihood of management errors. Handling and recording information, especially when creating daily and weekly reports, takes time and effort. In addition, inconsistent formats can make reports difficult for readers to understand. There is a need to solve these problems and achieve efficient, standardized task management and report creation.

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

[1120] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating a daily report based on the information in the database, means for saving the daily report in a predetermined format, and means for creating a weekly report, thereby enabling automatic acquisition of task information and efficient storage in the database, as well as automatic generation and saving of standardized daily and weekly reports.

[1121] "External system" refers to a system that manages and provides task information, and includes software such as project management tools and task management tools.

[1122] "Task information" is detailed information about a project or work unit, including the task name, person in charge, status, start date, and end date.

[1123] "Database" refers to an information storage system that stores acquired task information and allows for quick reference in subsequent processing.

[1124] A "daily report" is a report that details the progress and work content of tasks on a specific day.

[1125] A "weekly report" is a report that summarizes the progress of tasks for the week and helps you understand the progress of the entire project.

[1126] An "application programming interface (API)" refers to an interface for exchanging data between different software programs.

[1127] An "authentication token" is security information used when sending an API request to verify that the request is legitimate.

[1128] "JSON format" is an abbreviation for JavaScript Object Notation, and is a lightweight data exchange format for expressing data structures in text format.

[1129] "SQL statement" stands for Structured Query Language and is an instruction for interacting with a database management system.

[1130] A "template engine" is a software component that embeds dynamic data into standard text and is used to automatically generate reports.

[1131] The Markdown format is a lightweight markup language for writing plain text, and is a format that pursues ease of reading and writing.

[1132] "Excel format" is a file format used by Microsoft Excel, a spreadsheet software, for organizing data and performing calculations.

[1133] The present invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[1134] Retrieving task information from an external system

[1135] The server sends a request to an external system (e.g., a project management tool or task management tool) via API to obtain the required task information. To do this, the server uses a pre-prepared URL and authentication token. The obtained task information is then parsed in JSON format. Task information includes the task name, assignee, status, start date, end date, etc.

[1136] Specific examples

[1137] For example, when a server retrieves task information for "Project XYZ" from a project management tool, it sends an API request and receives task information in response, including the task name "Design Review," the assignee "Ichiro Sato," the status "In Progress," the start date "2023-11-01," and the end date "2023-11-05."

[1138] Store task information in a database

[1139] The server converts the acquired task information into SQL statements and stores them in a database. The database is SQL-based and saves the information in a format that corresponds to each field (task ID, name, person in charge, status, start date, end date, etc.).

[1140] Specific examples

[1141] After retrieving the "Design Review" task from the project management tool, save this information to the database using the SQL statement "INSERT INTO tasks (task_id, name, status, start_date, end_date) VALUES (1, 'Design Review', 'In Progress', '2023-11-01', '2023-11-05')".

[1142] Generate daily reports

[1143] The server automatically generates daily reports for each employee based on task information retrieved from the database. Daily reports are created using a template engine (e.g., Jinja2) and include detailed information about the work and progress of that day.

[1144] Specific examples

[1145] For example, when generating a daily report for employee "Ichiro Sato," the server automatically creates the report based on the task information for that day (e.g., task name "Design Review," status "Complete"), and uses a template to generate a daily report with content such as "Today's Task: Design Review, Status: Completed, Work Time: 5 hours."

[1146] Generate weekly reports

[1147] The server automatically generates weekly reports summarizing progress on a weekly basis based on the daily report data. Weekly reports are also created using a template engine.

[1148] Specific examples

[1149] For example, to see progress for a particular week, the server aggregates the daily report data and generates a weekly report that might include something like "Weekly tasks: Design Review, Project XYZ, Number of completed tasks: 5, Number of remaining tasks: 2."

[1150] Save the report

[1151] The server saves the generated daily and weekly reports in a specified format, such as Markdown or Excel. The saved reports are managed in a specific directory.

[1152] Specific examples

[1153] For example, files will be saved in formats such as "2023-11-05_Sato Ichiro_DailyReport.md" or "2023-W45_WeeklyReport.xlsx".

[1154] As described above, the system of the present invention can streamline and standardize work reports and progress management by acquiring data from external systems, storing it in a database, automatically generating daily and weekly reports, and saving the reports in a specified format. This is expected to significantly reduce the workload of employees and improve the performance of the entire company.

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

[1156] Step 1:

[1157] Retrieving task information from an external system

[1158] The server sends an API request to the external system to obtain the required task information. To do this, the server sends an HTTP GET request including a previously prepared URL and authentication token. The input required is the API endpoint of the external system and the authentication token. The output is the task information in JSON format, which is returned as a response. Specifically, the server constructs an HTTP request including the authentication token in the header and sends it to the API endpoint. The response is then parsed to extract the required task information.

[1159] Step 2:

[1160] Parsing task information and storing it in a database

[1161] The server parses the acquired JSON formatted task information and stores it in the database. The JSON data acquired in step 1 is required as input. The output is the task information stored in the database. Specifically, the server parses the acquired JSON data and extracts each field (task ID, name, assignee, status, start date, end date, etc.). It then generates an SQL statement and executes the INSERT statement on the database.

[1162] Step 3:

[1163] Generate daily reports

[1164] The server retrieves task information from the database and automatically generates daily reports for each employee. The input requires task information stored in the database. The output is the automatically generated daily report. Specifically, the server uses an SQL SELECT statement to retrieve task information for a specific employee from the database. It then uses a template engine (e.g., Jinja2) to embed the information in a template and generate the daily report.

[1165] Step 4:

[1166] Generate weekly reports

[1167] The server automatically generates weekly reports based on daily reports. The input requires daily report data from the database. The output is the generated weekly report. Specifically, the server uses an SQL SELECT statement to retrieve daily report data within a specific week range. It then aggregates this daily report data and generates the weekly report using a template engine.

[1168] Step 5:

[1169] Save the report

[1170] The server saves the generated daily and weekly reports in a specified format (Markdown or Excel). The automatically generated daily and weekly reports are required as input. The output is a file saved in the specified format. Specifically, the server uses a template engine to convert the generated report into a Markdown or Excel file and saves it in a specified directory. For example, the file is saved in a format such as "2023-11-05_EmployeeA_DailyReport.md" or "2023-W45_WeeklyReport.xlsx."

[1171] (Application example 1)

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

[1173] With conventional factory task management systems, it was difficult to accurately grasp the work progress of each robot and automatically generate daily and weekly reports. Furthermore, checking the progress of tasks performed by individual robots required a lot of manual work, which was inefficient and prone to information being lost. This resulted in a decline in overall productivity and made it difficult to share information in a timely manner.

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

[1175] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating daily reports based on the information in the database, means for saving the daily reports in a predetermined format, means for acquiring task information from a robot control system, storing the task information in a database, and saving daily and weekly reports automatically generated based on the robot's work progress, and means for checking the task progress status for a specified period using a generative AI model. This makes it possible to efficiently manage the robot's work progress and automatically generate and save daily and weekly reports.

[1176] An "external system" is an information system that provides task information from data outside the factory, project management tools, etc.

[1177] "Task information" is data consisting of information such as specific work content, person in charge, status, start date, and end date.

[1178] A "database" is a structured data storage system that stores acquired task information and allows quick reference as needed.

[1179] A "daily report" is a report detailing the work and progress of each robot on a particular day.

[1180] A "weekly report" is a report summarizing the progress of work during a particular week.

[1181] A "robot control system" is a system for managing and controlling the operation of robots within a factory.

[1182] A "generative AI model" is an artificial intelligence algorithm that identifies and analyzes task progress over a specified period of time.

[1183] A "prescribed format" is a document format that is established so that reports are saved in a unified format and are easy for readers to understand.

[1184] This invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is realized through the cooperation of a server, terminals, and users.

[1185] 1. Obtaining task information from an external system

[1186] The server sends a request via API to an external system (for example, an external data or project management tool) to obtain the required task information. Task information includes the task name, person in charge, status, start date, and end date. Specifically, the server uses the API of the factory's robot control system to obtain the work progress of each robot. This information includes the work content, the robot responsible for the work, the progress status, and the start and end dates.

[1187] 2. Store task information in a database

[1188] The server stores the acquired task information in a database, allowing for quick reference of the data required for subsequent processing. The database is configured using SQLite and stores detailed data for each task.

[1189] 3. Generate daily reports

[1190] The server automatically generates a daily report for each robot based on task information retrieved from the database. This daily report contains detailed information about the work and progress of that day. Specifically, the server extracts information about tasks performed on a specific day and automatically creates a daily report.

[1191] 4. Generate weekly reports

[1192] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. This allows you to grasp the overall progress status. The server aggregates the weekly task data and compiles it into a weekly report.

[1193] 5. Saving the report

[1194] The server saves the generated daily and weekly reports in a specified format. Based on this format, the reports are saved in a unified format, making them easy for readers to understand. For example, Markdown or Excel is used as the saving format.

[1195] 6. Leveraging generative AI models

[1196] The server uses the generative AI model to check the progress of a task over a specified period, allowing users to view the progress and time spent on a specific task through prompts.

[1197] For example, use the following prompt:

[1198] "I would like to check the progress of a specific task. Please let me know whether Robot A has completed the 'Parts assembly' task and how long it took between the start dates of 2023-10-01 and 2023-10-07."

[1199] With the above functions, the present invention can efficiently manage the work progress of robots in a factory and automatically generate and save daily and weekly reports.

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

[1201] Step 1:

[1202] The server obtains task information from an external system. Specifically, it sends an API request and receives task information as a response. The input is the API endpoint and authentication information of the external system, and the output is task information including the task name, person in charge, status, start date, and end date. For example, the API of a robot control system is used to obtain data on the work performed by a specific robot.

[1203] Step 2:

[1204] The server stores the acquired task information in the database. Specifically, it executes an INSERT query on the SQLite database. The input is the task information acquired in step 1, and the output is the task information stored in the database. This means that detailed data of each task (such as name, assignee, progress status, etc.) is accurately stored in the database.

[1205] Step 3:

[1206] The server automatically generates daily reports based on task information retrieved from the database. Specifically, it extracts task data related to a specific date using an SQL query and embeds it in a template. A specific date is specified as input, and the output is a daily report text that describes the work and progress of that day. For example, it generates a daily report that includes information that the "design review" task was completed that day.

[1207] Step 4:

[1208] The server automatically generates weekly reports based on the daily report information stored in the database. Specifically, it aggregates the daily report data for a specified week and embeds it back into the template. The input is the start and end dates, and the output is a weekly report text summarizing the progress for the week. For example, a weekly report can be generated that displays the number of tasks completed and the number of tasks remaining in a specific week.

[1209] Step 5:

[1210] The server saves the generated daily and weekly reports in a specified format. Specifically, the generated report text data is saved as a file in Markdown or Excel format. The input is the report text data, and the output is a file in the specified format. For example, the report is saved with a file name such as "2023-10-05_dailyreport.md".

[1211] Step 6:

[1212] The server uses the generative AI model to check the task progress for a specified period. Specifically, it analyzes the prompt text entered by the user, extracts the corresponding task data from the database, and processes it. The input is the prompt text entered by the user, and the output is the analysis results regarding the progress and work time within the specified period. For example, it can check progress such as "Has Robot A completed the 'assembly of parts' task?"

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

[1214] This invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information, in addition to combining it with an emotion engine that recognizes the user's emotions. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[1215] 1. Obtaining task information from an external system

[1216] The server sends a request via API to an external system (e.g., a project management tool or task management tool) to retrieve the required task information, including the task name, assignee, status, start date, end date, etc.

[1217] Natural language explanations

[1218] The server sends API requests to external systems to retrieve information about projects and tasks, which is then stored in a database.

[1219] Specific examples

[1220] For example, when a server retrieves task information for "Project ABC" from a project management tool, it sends an API request and receives task information (e.g., task name "Design Review," task owner "Yamada Taro," status "In Progress," etc.) in response.

[1221] 2. Store task information in a database

[1222] The server stores the acquired task information in a database, allowing the data required for subsequent processing to be quickly referenced.

[1223] Natural language explanations

[1224] The server stores task information obtained from external systems in a database. The saved data is used to generate daily and weekly reports.

[1225] Specific examples

[1226] The acquired task information (e.g., task name "Design Review", task owner "Yamada Taro", status "In Progress", start date "2023-10-01", end date "2023-10-05", etc.) is saved in the database.

[1227] 3. Emotion Recognition by Emotion Engine

[1228] The device receives voice input and facial recognition data from the user and analyzes the user's emotions using an emotion engine.

[1229] Natural language explanations

[1230] The device uses an emotion engine to analyze the user's emotions based on the user's voice input and facial recognition data obtained from camera footage. The analysis results influence the generation of subsequent daily reports.

[1231] Specific examples

[1232] When a user inputs voice into the device, the device sends the voice to the emotion engine, which analyzes the voice and recognizes emotions such as "joy," "sadness," and "anger."

[1233] 4. Generate daily reports

[1234] The server automatically generates daily reports for each employee based on task information retrieved from the database and the results of the emotion engine's analysis. The content of the daily reports is adjusted based on the results of the emotion analysis.

[1235] Natural language explanations

[1236] The server automatically generates the contents of the daily report based on the task information in the database and the results of emotion analysis, so that the user's mood and emotions are reflected in the daily report.

[1237] Specific examples

[1238] When generating a daily report for user "Yamada Taro," the server generates a daily report with content such as "Today, we progressed with the design review. It is progressing smoothly and I am very satisfied." based on task information (e.g., "Design review, in progress, 5 hours of work") and emotion analysis results (e.g., "Delighted").

[1239] 5. Saving daily reports

[1240] The server saves the generated daily reports in a predetermined format, which allows the daily reports to be saved in a unified format.

[1241] Natural language explanations

[1242] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format), so that the daily reports are stored in a unified format.

[1243] Specific examples

[1244] Save the generated daily report in a format such as "2023-10-05_Yamada Taro_DailyReport.md".

[1245] 6. Generate weekly reports

[1246] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database, and also takes into account the results of sentiment analysis.

[1247] Natural language explanations

[1248] The server automatically generates a weekly report summarizing the progress of a specific week based on the daily report data. The results of sentiment analysis are also reflected in the weekly report.

[1249] Specific examples

[1250] A weekly report is generated based on task information for the specified week (e.g., "5 completed tasks, 2 incomplete tasks") and sentiment analysis results (e.g., "Overall satisfaction was high this week").

[1251] 7. Saving weekly reports

[1252] The server saves the generated weekly reports in a predetermined format, which allows the weekly reports to be saved in a unified format.

[1253] Natural language explanations

[1254] The server saves the generated weekly reports in a specific folder in a specified format, so that the weekly reports are stored in a unified format.

[1255] Specific examples

[1256] Save the generated weekly report in the format "2023-10-01_To_2023-10-07_WeeklyReport.md".

[1257] The above is a specific embodiment of the present invention. By combining it with an emotion engine, it is possible to realize an advanced reporting system that not only manages tasks and reports progress, but also takes into account the emotions of users. This allows reports to be created that reflect the moods and motivations of employees, which is expected to improve the performance of the entire company.

[1258] The processing flow will be explained below.

[1259] Step 1:

[1260] The server sends a request to the API endpoint of the external system to obtain the required task information.

[1261] Specific actions

[1262] The server configures the API endpoint of the external system, along with the necessary query parameters and authentication information, and sends an API request to retrieve project and task information (e.g., task name, assignee, status, start date, end date, etc.).

[1263] python

[1264] url = "https: / / external-system.com / api / tasks"

[1265] params = {'project_id': 'ABC123'}

[1266] headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}

[1267] response = requests.get(url, params=params, headers=headers)

[1268] Step 2:

[1269] The server analyzes the response received from the external system and extracts the required information.

[1270] Specific actions

[1271] The server parses the API response in JSON format and extracts the required fields (e.g. task ID, name, assignee, status, time log, etc.) This data is either kept temporarily in memory for further processing or stored immediately in a database.

[1272] python

[1273] if response.status_code == 200:

[1274] tasks = response.json()

[1275] for task in tasks:

[1276] task_id = task['id']

[1277] task_name = task['name']

[1278] assignee = task['assignee']

[1279] status = task['status']

[1280] Processing to save to the database

[1281] Step 3:

[1282] The server stores the analyzed task information in a database.

[1283] Specific actions

[1284] The server saves the extracted task information to the appropriate table in the database by inserting each field (task ID, name, assignee, status, time log, etc.) into the corresponding column in the database.

[1285] python

[1286] def save_to_database(task):

[1287] connection = get_database_connection()

[1288] cursor = connection.cursor()

[1289] insert_query = """INSERT INTO tasks (task_id, name, assignee, status, time_log) VALUES (%s, %s, %s, %s, %s)"""

[1290] cursor.execute(insert_query, (task['id'], task['name'], task['assignee'], task['status'], task['time_log']))

[1291] connection.commit()

[1292] cursor.close()

[1293] connection.close()

[1294] Step 4:

[1295] The device receives the user's voice input and camera footage and sends them to an emotion recognition engine.

[1296] Specific actions

[1297] The device receives voice input from the user and camera footage in real time and sends the voice and image data to the emotion recognition engine.

[1298] python

[1299] def capture_user_input():

[1300] audio_data = record_audio()

[1301] video_data = capture_video()

[1302] return audio_data, video_data

[1303] Step 5:

[1304] The emotion recognition engine analyzes voice input and camera footage to recognize the user's emotions.

[1305] Specific actions

[1306] The emotion recognition engine analyzes the acquired voice and image data to recognize the user's emotions (e.g., joy, sadness, anger, etc.). The analysis results are sent to the server.

[1307] python

[1308] def analyze_emotion(audio_data, video_data):

[1309] emotion_results = emotion_engine.process(audio_data, video_data)

[1310] return emotion_results

[1311] Step 6:

[1312] The server stores the emotion recognition results in a database.

[1313] Specific actions

[1314] The server stores the analysis results (e.g., type and intensity of emotion) received from the emotion recognition engine in an appropriate table in the database.

[1315] python

[1316] def save_emotion_to_database(employee_id, emotion_results):

[1317] connection = get_database_connection()

[1318] cursor = connection.cursor()

[1319] insert_query = """INSERT INTO emotions (employee_id, emotion, intensity) VALUES (%s, %s, %s)"""

[1320] cursor.execute(insert_query, (employee_id, emotion_results['emotion'], emotion_results['intensity']))

[1321] connection.commit()

[1322] cursor.close()

[1323] connection.close()

[1324] Step 7:

[1325] The server retrieves task information and emotion recognition results for each employee from the database and generates a daily report.

[1326] Specific actions

[1327] The server issues a query to retrieve task information and emotion recognition results from the database for each employee, and automatically generates a daily report based on that information. The generated report includes information such as task name, person in charge, status, working time, and type and intensity of emotion.

[1328] python

[1329] employee_id = "yamada_taro"

[1330] tasks = get_tasks(employee_id)

[1331] emotions = get_emotions(employee_id)

[1332] daily_report = f"""

[1333] Daily report for {datetime.now().date()}

[1334] task

[1335] {tasks}

[1336] emotions

[1337] {emotions}

[1338] """

[1339] Step 8:

[1340] The server saves the generated daily report in a specified format.

[1341] Specific actions

[1342] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format). This operation ensures that the daily reports are stored in a unified format, making them easier to refer to later.

[1343] python

[1344] with open(f" / path / to / reports / {employee_id}_daily_report.txt", "w") as file:

[1345] file.write(daily_report)

[1346] Step 9:

[1347] The server automatically generates a weekly report based on the daily report.

[1348] Specific actions

[1349] The server aggregates the daily report data stored in the database and generates a weekly report that reflects the progress and sentiment analysis results for the week. The weekly report includes the progress of each task, the number of completed tasks, the number of incomplete tasks, and an overview of the user's sentiment.

[1350] python

[1351] week_start = "2023-10-01"

[1352] week_end = "2023-10-07"

[1353] weekly_reports = get_weekly_reports(week_start, week_end)

[1354] weekly_report = f"""

[1355] Weekly report from {week_start} to {week_end}

[1356] {weekly_reports}

[1357] """

[1358] Step 10:

[1359] The server saves the generated weekly report in a specified format.

[1360] Specific actions

[1361] The server saves the generated weekly reports in a specific folder in a specified format. This operation ensures that the weekly reports are stored in a standardized format, making it easier to manage the progress of the entire project.

[1362] python

[1363] with open(" / path / to / reports / weekly_report.txt", "w") as file:

[1364] file.write(weekly_report)

[1365] These are the specific processing steps of the present invention. By combining it with an emotion engine, it is possible to realize an advanced reporting system that not only manages tasks and reports progress, but also takes into account the emotions of users. This allows reports to be created that reflect the moods and motivations of employees, which is expected to improve the performance of the entire company.

[1366] Example 2

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

[1368] In today's work environment, task management and progress reporting are important, but one-way reporting systems that don't take into account employee emotions and motivation have limitations in improving work efficiency and employee satisfaction. Furthermore, manually creating daily and weekly reports is time-consuming and labor-intensive, making them inefficient. To solve these problems, a reporting system that combines automatic task information acquisition and emotion analysis is needed.

[1369] 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 acquiring task information from an external system, a means for storing the acquired task information in a database, a sentiment analysis means for analyzing the user's sentiment, a means for creating a daily report based on the information in the database and the sentiment analysis results, and a means for saving the daily report in a predetermined format. This makes it possible to automatically generate a report that integrates task information and sentiment information, thereby realizing advanced task management and progress reporting that reflects the sentiments of employees.

[1370] An "external system" is a system that provides task information, such as a project management tool or a task management tool.

[1371] "Task information" is a series of information about a task, such as the task name, person in charge, status, start date, and end date.

[1372] A "database" is a data storage system that stores acquired task information and enables quick reference to data required for subsequent processing.

[1373] The "emotion analysis means" is a system that analyzes the user's voice input and facial recognition data, and identifies the user's emotions as labels such as "joy," "sadness," and "anger."

[1374] A "daily report" is a report summarizing daily work and progress based on database information and sentiment analysis results.

[1375] A "weekly report" is a report that summarizes progress on a weekly basis based on daily reports.

[1376] A "prescribed format" is a standardized file format that ensures reports are saved in a consistent format, including Markdown and Excel formats.

[1377] This invention is a system that acquires task information from an external system, stores it in a database, and then analyzes user emotions to automatically generate daily and weekly reports. This system is implemented mainly with the cooperation of a server, terminals, and users.

[1378] Hardware and Software Configuration

[1379] The server connects to external systems via an application programming interface (API) for communicating with project management tools and task management tools. The server also requires a database connection driver such as ODBC or JDBC to store the acquired task information in a database. Programming languages ​​and libraries such as Python or Java are also used to generate daily and weekly reports using sentiment analysis and generative AI models.

[1380] The device has hardware and software to capture user voice input and camera footage and send it to an emotion analysis engine, including a microphone, camera, and voice and facial recognition software.

[1381] The user uses a terminal to input data (audio, video, etc.) for the daily report. The audio and video data input by the user is sent to the emotion analysis engine via the terminal.

[1382] Specific operation of the system

[1383] 1. Get task information

[1384] The server sends an HTTP request to the API of the external system to obtain task information. The obtained information is received in JSON format and parsed. For example, obtain task information for "Project XYZ" from a project management tool.

[1385] 2. Storage in the database

[1386] The server uses SQL INSERT and UPDATE statements to store the retrieved task information in the database, so that the task information is saved in the database and can be quickly referenced at any time.

[1387] 3. Emotion analysis

[1388] The device receives voice input and camera footage from the user and sends it to an emotion analysis engine. The analysis engine analyzes the audio and video data and identifies the user's emotion as a label such as "happiness," "sadness," or "anger." For example, if a user says to the device, "Today's meeting was very constructive," the emotion engine will interpret it as "happiness."

[1389] 4. Generate daily and weekly reports

[1390] The server generates a daily report based on task information retrieved from the database and the results of sentiment analysis. A generative AI model is used in this process. A prompt such as "Please generate a daily report based on today's work content and emotions" is sent to the model. The generated daily report is saved in a specified format such as Markdown or Excel.

[1391] 5. Saving and Referencing

[1392] Daily reports are saved in a specific folder by the server, and weekly reports are saved in the same way. For example, the daily report is saved as "2023-10-05_EmployeeA_DailyReport.md" and the weekly report is saved as "2023-10-01_To_2023-10-07_WeeklyReport.md".

[1393] In this way, by automatically generating reports that integrate task information and emotional information, it is possible to achieve advanced task management and progress reports that reflect employees' emotions, enabling effective business operations that take into account employees' moods and motivations.

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

[1395] Step 1:

[1396] The server obtains task information from an external system. Specifically, the server sends an HTTP GET request to the external system's API and receives task information in JSON format. The input is the API request parameters (e.g., project ID), and the output is the JSON-formatted task information received as a response. The server parses this task information and extracts the necessary data items (e.g., task name, assignee, status, start date, and end date).

[1397] Step 2:

[1398] The server stores the extracted task information in a database. The input is the extracted task information, and the output is the newly added or updated data in the database. Specifically, the server generates SQL INSERT or UPDATE statements and executes them against the database via ODBC or JDBC. This saves the task information in the database.

[1399] Step 3:

[1400] The device receives voice input and camera footage from the user and prepares it as data for emotion analysis. The input is the user's voice and video data, and the output is data converted into the format required for analysis. Specifically, the device sends the data acquired by the microphone and camera to the emotion analysis engine in real time.

[1401] Step 4:

[1402] The server receives the emotion data analyzed by the emotion analysis engine and uses it as data for generating daily reports. The input is the analyzed emotion data (e.g., "joy," "sadness," "anger"), and the output is daily report data that combines this emotion data with task information. Specifically, the server integrates the emotion data with task information and sends prompt sentences to the generative AI model.

[1403] Step 5:

[1404] The generative AI model generates daily reports based on prompts received from the server. The input is data (task information and emotion data) integrated with the prompt, and the output is the generated daily report text. Specifically, a prompt such as "Please generate a daily report based on today's work content and emotions" is input into the model, and the generated daily report text is obtained.

[1405] Step 6:

[1406] The server saves the generated daily report in a specified format (e.g., Markdown format, Excel format). The input is the generated daily report text, and the output is a daily report file saved in the specified file format. Specifically, the content of the daily report is converted to Markdown or Excel format and saved in the file system.

[1407] Step 7:

[1408] The server retrieves one week's worth of daily report data from the database and automatically generates a weekly report based on this. The input is the daily report data, and the output is the generated weekly report text. Specifically, the server aggregates the daily report data and sends a prompt message to the generative AI model saying, "Please generate a weekly report based on the work content and emotions of the past week," to generate the weekly report.

[1409] Step 8:

[1410] The server saves the generated weekly report in a specified format. The input is the generated weekly report text, and the output is a weekly report file saved in a specified file format. Specifically, the contents of the weekly report are converted to Markdown or Excel format and saved in the file system.

[1411] (Application example 2)

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

[1413] In conventional factory environments, worker task management and progress reporting are often done manually, resulting in reduced efficiency. Furthermore, because the emotions and motivation of workers are not taken into account, this can have a negative impact on work efficiency and safety. Therefore, there is a need for a system that integrates task management and emotion recognition to provide efficient and comprehensive management.

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

[1415] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating a daily report based on the information in the database, means for saving the daily report in a predetermined format, means for acquiring a user's voice input or facial recognition data and analyzing their emotions, and means for adjusting the content of the daily report based on the emotion analysis results. This enables integrated management of the task progress and emotional state of workers, enabling efficient work instructions and appropriate motivation management.

[1416] An "external system" is a system that allows factory robots and workers to obtain information from task management tools, databases, etc.

[1417] "Task information" is information such as the name of the work to be performed in the factory, the person in charge, the status, the start date, and the end date.

[1418] A "database" is an information management system that stores acquired task information and facilitates search and extraction.

[1419] A "daily report" is a report used to record and store the progress of work and emotional state of the day.

[1420] A "weekly report" is a report summarizing work progress and emotional state for a particular week.

[1421] "Emotion analysis" is the process of identifying and analyzing a user's emotional state based on their voice input and facial recognition data.

[1422] The "emotion engine" is a software component that analyzes voice input and facial recognition data to classify the user's emotions into categories such as "joy," "sadness," and "anger."

[1423] A "server" is a computer system that acquires data from external systems, stores it in a database, and generates and saves daily and weekly reports.

[1424] "Voice input" is an interface where a user provides data to a system using their voice.

[1425] "Facial recognition data" refers to image data of a user's face acquired using a device such as a camera.

[1426] The "prescribed format" refers to a standardized format in which daily and weekly reports are saved, such as Markdown format or Excel format.

[1427] MODE FOR CARRYING OUT THE INVENTION

[1428] The present invention is a system that integrates task management and emotion recognition for workers in a factory. Hereinafter, an embodiment of the present invention will be described in detail.

[1429] 1. Obtaining task information from an external system

[1430] The server sends a request to an external system (e.g., a task management tool) via an application programming interface (API) to obtain the required task information, including the task name, person in charge, status, start date, end date, etc. The obtained task information is stored in a database by the server.

[1431] 2. Storing task information in a database

[1432] The server stores the task information obtained from the external system in a database. This operation establishes data storage that can be quickly referenced in subsequent processes. In addition to task information, the database also stores worker emotion data.

[1433] 3. Emotion Recognition by Emotion Engine

[1434] The device receives voice input and facial recognition data from the user. This data is analyzed by an emotion engine, which classifies the user's emotions into categories such as "happiness," "sadness," and "anger." The analysis results are stored in a database and reflected in the content of daily and weekly reports.

[1435] 4. Generate daily reports

[1436] The server automatically generates daily reports for each worker based on task information retrieved from the database and the results of the emotion engine's analysis. The content of the daily reports is adjusted based on the results of the emotion analysis.

[1437] 5. Saving daily reports

[1438] The server saves the generated daily reports in a specified format (for example, Markdown or Excel format). This format ensures that the daily reports are stored in a unified format.

[1439] 6. Generate weekly reports

[1440] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database, and also takes into account the results of sentiment analysis.

[1441] 7. Saving weekly reports

[1442] The server saves the generated weekly reports in a specified format, which allows the weekly reports to be stored in a unified format.

[1443] A concrete example of how this system works is the process in which a factory worker uses a smartphone to input task progress and record their emotions through voice input. For example, the worker might say, "I'm glad that work went smoothly today." This voice data is analyzed by the emotion engine and recognized as "joy." As a result, the server automatically generates a daily report based on this information, saying, "Work went smoothly today. I'm satisfied," and saves it in a specified format.

[1444] The specific hardware used includes smartphones and factory robots, the software uses Python and SQLite, and retrieves data from external systems via APIs, and an emotion engine is used for emotion analysis.

[1445] Further examples of leveraging generative AI models include prompts such as:

[1446] One day, you have to create a system for reporting work at a factory. Write a program that retrieves task information from an external task management tool, stores it in a database, and generates daily and weekly reports. You also need to incorporate a function to analyze user sentiment and reflect the results in the reports.

[1447] This type of structure allows for efficient work instructions, appropriate motivation management, and integrated task and emotion management.

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

[1449] Step 1:

[1450] Retrieving task information from an external system

[1451] The server sends an API request to an external system (such as a task management tool) to obtain the required task information. As input, the request data for the task information to be obtained (e.g., project ID and authentication information) is provided. As output, the obtained task information (e.g., task name, assignee, status, start date, end date) is obtained. This task information is passed to the server in JSON format. The server stores this information in temporary memory.

[1452] Step 2:

[1453] Storing task information in a database

[1454] The server stores the retrieved task information in a database. The task information retrieved in step 1 is used as input. The server inserts the task information into the database using an SQL query. The output is confirmation of the newly added task information in the database. This establishes data storage that can be quickly referenced in subsequent processes.

[1455] Step 3:

[1456] Emotion recognition by emotion engine

[1457] The device receives voice input or facial recognition data from the user. Inputs include voice data and camera image data provided by the user to the device. The device sends this data to the emotion engine, which analyzes the emotions. The output is analyzed emotion data (e.g., "joy," "sadness," "anger," etc.). The analyzed emotion data is registered in a database. This information is used when generating daily reports.

[1458] Step 4:

[1459] Generate daily reports

[1460] The server retrieves task information and the emotion engine's analysis results from the database and automatically generates daily reports for each user. The user's task information and emotion data are retrieved from the database as input. The server creates the text content of the daily report based on this data. The generated text data of the daily report is obtained as output. This text data is used in subsequent processing.

[1461] Step 5:

[1462] Saving daily reports

[1463] The server saves the generated daily report in a specified format (Markdown or Excel format). The input is the text data of the generated daily report. The server uses a file manipulation library to save the file in the specified format. As an output, the daily report file is saved in a specified folder. This file is referenced later.

[1464] Step 6:

[1465] Generate weekly reports

[1466] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. Daily report information for a specified week is retrieved from the database as input. The server creates the text content of the weekly report based on this data. The output is the text data of the generated weekly report.

[1467] Step 7:

[1468] Saving weekly reports

[1469] The server saves the generated weekly report in a specified format. The input is the text data of the generated weekly report. The server uses a file operation library to save the file in the specified format. As an output, the weekly report file is saved in a specified folder. This file is referenced later.

[1470] In this way, daily and weekly reports based on task information and emotion data are efficiently generated and stored.

[1471] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

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

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

[1474] [Fourth embodiment]

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

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

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

[1478] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

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

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

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

[1482] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1483] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

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

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

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

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

[1488] The present invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[1489] 1. Obtaining task information from an external system

[1490] The server sends a request to an external system (e.g., a project management tool or task management tool) via API to obtain the necessary task information, including the task name, assignee, status, start date, end date, etc.

[1491] Natural language explanations

[1492] The server sends API requests to external systems to retrieve information about projects and tasks, including task names, assignees, statuses, start and end dates, and so on, and stores this data in a database.

[1493] Specific examples

[1494] For example, when the server retrieves task information for "Project ABC" from a project management tool, it sends an API request and receives task information in response, including the task name "Design Review," the person in charge "Yamada Taro," the status "In Progress," the start date "2023-10-01," and the end date "2023-10-05."

[1495] 2. Store task information in a database

[1496] The server stores the acquired task information in a database, allowing the data required for subsequent processing to be quickly referenced.

[1497] Natural language explanations

[1498] The server stores the task information obtained from the external system in a database, which is used to generate future daily and weekly reports.

[1499] Specific examples

[1500] If the task information obtained from the project management tool is a "design review" task, save this information to the database. The fields saved in the database include the task ID, name, assignee, status, time log, etc.

[1501] 3. Generate daily reports

[1502] The server automatically generates daily reports for each employee based on task information retrieved from the database, detailing the work and progress of that day.

[1503] Natural language explanations

[1504] The server automatically generates daily reports for each employee based on task information in the database. The daily reports contain detailed information about the work done that day and the progress made, allowing employees to submit reports of a consistent quality without any effort.

[1505] Specific examples

[1506] For example, when generating a daily report for employee "Yamada Taro," the server automatically creates the report based on the task information for that day (e.g., task name "Design Review," status "Complete"). The daily report will include information such as "Today's Task: Design Review, Status: Completed, Work Time: 5 hours."

[1507] 4. Generate weekly reports

[1508] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. This weekly report is used to grasp the overall progress of the project.

[1509] Natural language explanations

[1510] The server automatically generates a weekly report summarizing the progress of a specific week based on the daily report data, allowing the progress of the entire project to be grasped at a glance.

[1511] Specific examples

[1512] For example, to check weekly progress, the server aggregates the daily report data in the database and generates a weekly report that includes information such as "Weekly tasks: Design review, Project ABC, Number of completed tasks: 5, Number of remaining tasks: 2."

[1513] 5. Saving the report

[1514] The server saves the generated daily and weekly reports in a specified format. Based on this format, the reports are saved in a unified format, making them easy for readers to understand.

[1515] Natural language explanations

[1516] The server stores automatically generated daily and weekly reports in a specified format, which allows the reports to be presented in a standardized format that is easy for readers to understand.

[1517] Specific examples

[1518] For example, when saving a daily report generated by the server, it saves it to a file in a specific format (e.g., Markdown or Excel format). This file is saved in a format such as "2023-10-05_Yamada Taro_DailyReport.md."

[1519] As described above, the system of the present invention can streamline and standardize work reporting and progress management by acquiring data from external systems, storing it in a database, automatically generating daily and weekly reports, and saving the reports in a specified format. This significantly reduces the workload of employees and improves the performance of the entire company.

[1520] The processing flow will be explained below.

[1521] Step 1:

[1522] The server sends a request to the API endpoint of the external system to obtain the required task information.

[1523] Specific actions

[1524] The server configures the API endpoint of the external system, along with the necessary query parameters and authentication information, and sends an API request to retrieve project and task information (e.g., task name, assignee, status, start date, end date, etc.).

[1525] python

[1526] url = "https: / / external-system.com / api / tasks"

[1527] params = {'project_id': 'ABC123'}

[1528] headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}

[1529] response = requests.get(url, params=params, headers=headers)

[1530] Step 2:

[1531] The server analyzes the response received from the external system and extracts the required information.

[1532] Specific actions

[1533] The server parses the API response in JSON format and extracts the required fields (e.g. task ID, name, assignee, status, time log, etc.) This data is either kept temporarily in memory for further processing or stored immediately in a database.

[1534] python

[1535] if response.status_code == 200:

[1536] tasks = response.json()

[1537] for task in tasks:

[1538] task_id = task['id']

[1539] task_name = task['name']

[1540] assignee = task['assignee']

[1541] status = task['status']

[1542] Processing to save to the database

[1543] Step 3:

[1544] The server stores the analyzed task information in a database.

[1545] Specific actions

[1546] The server saves the extracted task information to the appropriate table in the database by inserting each field (task ID, name, assignee, status, time log, etc.) into the corresponding column in the database.

[1547] python

[1548] def save_to_database(task):

[1549] connection = get_database_connection()

[1550] cursor = connection.cursor()

[1551] insert_query = """INSERT INTO tasks (task_id, name, assignee, status, time_log) VALUES (%s, %s, %s, %s, %s)"""

[1552] cursor.execute(insert_query, (task['id'], task['name'], task['assignee'], task['status'], task['time_log']))

[1553] connection.commit()

[1554] cursor.close()

[1555] connection.close()

[1556] Step 4:

[1557] The server retrieves task information for each employee from the database and generates a daily report.

[1558] Specific actions

[1559] The server queries the database for task information for each employee and automatically generates daily reports based on that information, including task name, person in charge, status, and work time.

[1560] python

[1561] employee_id = "yamada_taro"

[1562] jira_tickets = get_jira_tickets(employee_id)

[1563] confluence_updates = get_confluence_updates(employee_id)

[1564] commits = get_commit_history(employee_id)

[1565] daily_report = f"""

[1566] Daily report for {datetime.now().date()}

[1567] JIRA Tickets

[1568] {jira_tickets}

[1569] Confluence Update History

[1570] {confluence_updates}

[1571] Commit History

[1572] {commits}

[1573] """

[1574] Step 5:

[1575] The server saves the generated daily report in a specified format.

[1576] Specific actions

[1577] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format). This operation ensures that the daily reports are stored in a unified format, making them easier to refer to later.

[1578] python

[1579] with open(f" / path / to / reports / {employee_id}_daily_report.txt", "w") as file:

[1580] file.write(daily_report)

[1581] Step 6:

[1582] The server automatically generates a weekly report based on the daily report.

[1583] Specific actions

[1584] The server aggregates the daily report data stored in the database and generates a weekly report that reflects the progress for one week. The weekly report includes the progress of each task, the number of completed tasks, and the number of uncompleted tasks.

[1585] python

[1586] week_start = "2023-10-01"

[1587] week_end = "2023-10-07"

[1588] weekly_reports = get_weekly_reports(week_start, week_end)

[1589] weekly_report = f"""

[1590] Weekly report from {week_start} to {week_end}

[1591] {weekly_reports}

[1592] """

[1593] Step 7:

[1594] The server saves the generated weekly report in a specified format.

[1595] Specific actions

[1596] The server saves the generated weekly reports in a specific folder in a specified format. This operation ensures that the weekly reports are stored in a standardized format, making it easier to manage the progress of the entire project.

[1597] python

[1598] with open(" / path / to / reports / weekly_report.txt", "w") as file:

[1599] file.write(weekly_report)

[1600] The above are the specific processing steps of the present invention. Through each step, daily and weekly reports can be automatically generated efficiently and in a unified format, reducing the workload of employees and improving the efficiency of company-wide progress management.

[1601] Example 1

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

[1603] Conventional task management systems require the manual collection and organization of diverse project and task information, resulting in workload burdens and a high likelihood of management errors. Handling and recording information, especially when creating daily and weekly reports, takes time and effort. In addition, inconsistent formats can make reports difficult for readers to understand. There is a need to solve these problems and achieve efficient, standardized task management and report creation.

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

[1605] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating a daily report based on the information in the database, means for saving the daily report in a predetermined format, and means for creating a weekly report, thereby enabling automatic acquisition of task information and efficient storage in the database, as well as automatic generation and saving of standardized daily and weekly reports.

[1606] "External system" refers to a system that manages and provides task information, and includes software such as project management tools and task management tools.

[1607] "Task information" is detailed information about a project or work unit, including the task name, person in charge, status, start date, and end date.

[1608] "Database" refers to an information storage system that stores acquired task information and allows for quick reference in subsequent processing.

[1609] A "daily report" is a report that details the progress and work content of tasks on a specific day.

[1610] A "weekly report" is a report that summarizes the progress of tasks for the week and helps you understand the progress of the entire project.

[1611] An "application programming interface (API)" refers to an interface for exchanging data between different software programs.

[1612] An "authentication token" is security information used when sending an API request to verify that the request is legitimate.

[1613] "JSON format" is an abbreviation for JavaScript Object Notation, and is a lightweight data exchange format for expressing data structures in text format.

[1614] "SQL statement" stands for Structured Query Language and is an instruction for interacting with a database management system.

[1615] A "template engine" is a software component that embeds dynamic data into standard text and is used to automatically generate reports.

[1616] The Markdown format is a lightweight markup language for writing plain text, and is a format that pursues ease of reading and writing.

[1617] "Excel format" is a file format used by Microsoft Excel, a spreadsheet software, for organizing data and performing calculations.

[1618] The present invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[1619] Retrieving task information from an external system

[1620] The server sends a request to an external system (e.g., a project management tool or task management tool) via API to obtain the required task information. To do this, the server uses a pre-prepared URL and authentication token. The obtained task information is then parsed in JSON format. Task information includes the task name, assignee, status, start date, end date, etc.

[1621] Specific examples

[1622] For example, when a server retrieves task information for "Project XYZ" from a project management tool, it sends an API request and receives task information in response, including the task name "Design Review," the assignee "Ichiro Sato," the status "In Progress," the start date "2023-11-01," and the end date "2023-11-05."

[1623] Store task information in a database

[1624] The server converts the acquired task information into SQL statements and stores them in a database. The database is SQL-based and saves the information in a format that corresponds to each field (task ID, name, person in charge, status, start date, end date, etc.).

[1625] Specific examples

[1626] After retrieving the "Design Review" task from the project management tool, save this information to the database using the SQL statement "INSERT INTO tasks (task_id, name, status, start_date, end_date) VALUES (1, 'Design Review', 'In Progress', '2023-11-01', '2023-11-05')".

[1627] Generate daily reports

[1628] The server automatically generates daily reports for each employee based on task information retrieved from the database. Daily reports are created using a template engine (e.g., Jinja2) and include detailed information about the work and progress of that day.

[1629] Specific examples

[1630] For example, when generating a daily report for employee "Ichiro Sato," the server automatically creates the report based on the task information for that day (e.g., task name "Design Review," status "Complete"), and uses a template to generate a daily report with content such as "Today's Task: Design Review, Status: Completed, Work Time: 5 hours."

[1631] Generate weekly reports

[1632] The server automatically generates weekly reports summarizing progress on a weekly basis based on the daily report data. Weekly reports are also created using a template engine.

[1633] Specific examples

[1634] For example, to see progress for a particular week, the server aggregates the daily report data and generates a weekly report that might include something like "Weekly tasks: Design Review, Project XYZ, Number of completed tasks: 5, Number of remaining tasks: 2."

[1635] Save the report

[1636] The server saves the generated daily and weekly reports in a specified format, such as Markdown or Excel. The saved reports are managed in a specific directory.

[1637] Specific examples

[1638] For example, files will be saved in formats such as "2023-11-05_Sato Ichiro_DailyReport.md" or "2023-W45_WeeklyReport.xlsx".

[1639] As described above, the system of the present invention can streamline and standardize work reports and progress management by acquiring data from external systems, storing it in a database, automatically generating daily and weekly reports, and saving the reports in a specified format. This is expected to significantly reduce the workload of employees and improve the performance of the entire company.

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

[1641] Step 1:

[1642] Retrieving task information from an external system

[1643] The server sends an API request to the external system to obtain the required task information. To do this, the server sends an HTTP GET request including a previously prepared URL and authentication token. The input required is the API endpoint of the external system and the authentication token. The output is the task information in JSON format, which is returned as a response. Specifically, the server constructs an HTTP request including the authentication token in the header and sends it to the API endpoint. The response is then parsed to extract the required task information.

[1644] Step 2:

[1645] Parsing task information and storing it in a database

[1646] The server parses the acquired JSON formatted task information and stores it in the database. The JSON data acquired in step 1 is required as input. The output is the task information stored in the database. Specifically, the server parses the acquired JSON data and extracts each field (task ID, name, assignee, status, start date, end date, etc.). It then generates an SQL statement and executes the INSERT statement on the database.

[1647] Step 3:

[1648] Generate daily reports

[1649] The server retrieves task information from the database and automatically generates daily reports for each employee. The input requires task information stored in the database. The output is the automatically generated daily report. Specifically, the server uses an SQL SELECT statement to retrieve task information for a specific employee from the database. It then uses a template engine (e.g., Jinja2) to embed the information in a template and generate the daily report.

[1650] Step 4:

[1651] Generate weekly reports

[1652] The server automatically generates weekly reports based on daily reports. The input requires daily report data from the database. The output is the generated weekly report. Specifically, the server uses an SQL SELECT statement to retrieve daily report data within a specific week range. It then aggregates this daily report data and generates the weekly report using a template engine.

[1653] Step 5:

[1654] Save the report

[1655] The server saves the generated daily and weekly reports in a specified format (Markdown or Excel). The automatically generated daily and weekly reports are required as input. The output is a file saved in the specified format. Specifically, the server uses a template engine to convert the generated report into a Markdown or Excel file and saves it in a specified directory. For example, the file is saved in a format such as "2023-11-05_EmployeeA_DailyReport.md" or "2023-W45_WeeklyReport.xlsx."

[1656] (Application example 1)

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

[1658] With conventional factory task management systems, it was difficult to accurately grasp the work progress of each robot and automatically generate daily and weekly reports. Furthermore, checking the progress of tasks performed by individual robots required a lot of manual work, which was inefficient and prone to information being lost. This resulted in a decline in overall productivity and made it difficult to share information in a timely manner.

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

[1660] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating daily reports based on the information in the database, means for saving the daily reports in a predetermined format, means for acquiring task information from a robot control system, storing the task information in a database, and saving daily and weekly reports automatically generated based on the robot's work progress, and means for checking the task progress status for a specified period using a generative AI model. This makes it possible to efficiently manage the robot's work progress and automatically generate and save daily and weekly reports.

[1661] An "external system" is an information system that provides task information from data outside the factory, project management tools, etc.

[1662] "Task information" is data consisting of information such as specific work content, person in charge, status, start date, and end date.

[1663] A "database" is a structured data storage system that stores acquired task information and allows quick reference as needed.

[1664] A "daily report" is a report detailing the work and progress of each robot on a particular day.

[1665] A "weekly report" is a report summarizing the progress of work during a particular week.

[1666] A "robot control system" is a system for managing and controlling the operation of robots within a factory.

[1667] A "generative AI model" is an artificial intelligence algorithm that identifies and analyzes task progress over a specified period of time.

[1668] A "prescribed format" is a document format that is established so that reports are saved in a unified format and are easy for readers to understand.

[1669] This invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information. This system is realized through the cooperation of a server, terminals, and users.

[1670] 1. Obtaining task information from an external system

[1671] The server sends a request via API to an external system (for example, an external data or project management tool) to obtain the required task information. Task information includes the task name, person in charge, status, start date, and end date. Specifically, the server uses the API of the factory's robot control system to obtain the work progress of each robot. This information includes the work content, the robot responsible for the work, the progress status, and the start and end dates.

[1672] 2. Store task information in a database

[1673] The server stores the acquired task information in a database, allowing for quick reference of the data required for subsequent processing. The database is configured using SQLite and stores detailed data for each task.

[1674] 3. Generate daily reports

[1675] The server automatically generates a daily report for each robot based on task information retrieved from the database. This daily report contains detailed information about the work and progress of that day. Specifically, the server extracts information about tasks performed on a specific day and automatically creates a daily report.

[1676] 4. Generate weekly reports

[1677] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. This allows you to grasp the overall progress status. The server aggregates the weekly task data and compiles it into a weekly report.

[1678] 5. Saving the report

[1679] The server saves the generated daily and weekly reports in a specified format. Based on this format, the reports are saved in a unified format, making them easy for readers to understand. For example, Markdown or Excel is used as the saving format.

[1680] 6. Utilizing generative AI models

[1681] The server uses the generative AI model to check the progress of a task over a specified period, allowing users to view the progress and time spent on a specific task through prompts.

[1682] For example, use the following prompt:

[1683] "I would like to check the progress of a specific task. Please let me know whether Robot A has completed the 'Parts assembly' task and how long it took between the start dates of 2023-10-01 and 2023-10-07."

[1684] With the above functions, the present invention can efficiently manage the work progress of robots in a factory and automatically generate and save daily and weekly reports.

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

[1686] Step 1:

[1687] The server obtains task information from an external system. Specifically, it sends an API request and receives task information as a response. The input is the API endpoint and authentication information of the external system, and the output is task information including the task name, person in charge, status, start date, and end date. For example, the API of a robot control system is used to obtain data on the work performed by a specific robot.

[1688] Step 2:

[1689] The server stores the acquired task information in the database. Specifically, it executes an INSERT query on the SQLite database. The input is the task information acquired in step 1, and the output is the task information stored in the database. This means that detailed data of each task (such as name, assignee, progress status, etc.) is accurately stored in the database.

[1690] Step 3:

[1691] The server automatically generates daily reports based on task information retrieved from the database. Specifically, it extracts task data related to a specific date using an SQL query and embeds it in a template. A specific date is specified as input, and the output is a daily report text that describes the work and progress of that day. For example, it generates a daily report that includes information that the "design review" task was completed that day.

[1692] Step 4:

[1693] The server automatically generates weekly reports based on the daily report information stored in the database. Specifically, it aggregates the daily report data for a specified week and embeds it back into the template. The input is the start and end dates, and the output is a weekly report text summarizing the progress for the week. For example, a weekly report can be generated that displays the number of tasks completed and the number of tasks remaining in a specific week.

[1694] Step 5:

[1695] The server saves the generated daily and weekly reports in a specified format. Specifically, the generated report text data is saved as a file in Markdown or Excel format. The input is the report text data, and the output is a file in the specified format. For example, the report is saved with a file name such as "2023-10-05_dailyreport.md".

[1696] Step 6:

[1697] The server uses the generative AI model to check the task progress for a specified period. Specifically, it analyzes the prompt text entered by the user, extracts the corresponding task data from the database, and processes it. The input is the prompt text entered by the user, and the output is the analysis results regarding the progress and work time within the specified period. For example, it can check progress such as "Has Robot A completed the 'assembly of parts' task?"

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

[1699] This invention is a system that acquires task information from an external system, stores the acquired task information in a database, and creates daily and weekly reports based on this information, in addition to combining it with an emotion engine that recognizes the user's emotions. This system is implemented as follows, with the cooperation of a server, terminals, and users.

[1700] 1. Obtaining task information from an external system

[1701] The server sends a request via API to an external system (e.g., a project management tool or task management tool) to retrieve the required task information, including the task name, assignee, status, start date, end date, etc.

[1702] Natural language explanations

[1703] The server sends API requests to external systems to retrieve information about projects and tasks, which is then stored in a database.

[1704] Specific examples

[1705] For example, when a server retrieves task information for "Project ABC" from a project management tool, it sends an API request and receives task information (e.g., task name "Design Review," task owner "Yamada Taro," status "In Progress," etc.) in response.

[1706] 2. Store task information in a database

[1707] The server stores the acquired task information in a database, allowing the data required for subsequent processing to be quickly referenced.

[1708] Natural language explanations

[1709] The server stores task information obtained from external systems in a database. The saved data is used to generate daily and weekly reports.

[1710] Specific examples

[1711] The acquired task information (e.g., task name "Design Review", task owner "Yamada Taro", status "In Progress", start date "2023-10-01", end date "2023-10-05", etc.) is saved in the database.

[1712] 3. Emotion Recognition by Emotion Engine

[1713] The device receives voice input and facial recognition data from the user and analyzes the user's emotions using an emotion engine.

[1714] Natural language explanations

[1715] The device uses an emotion engine to analyze the user's emotions based on the user's voice input and facial recognition data obtained from camera footage. The analysis results influence the generation of subsequent daily reports.

[1716] Specific examples

[1717] When a user inputs voice into the device, the device sends the voice to the emotion engine, which analyzes the voice and recognizes emotions such as "joy," "sadness," and "anger."

[1718] 4. Generate daily reports

[1719] The server automatically generates daily reports for each employee based on task information retrieved from the database and the results of the emotion engine's analysis. The content of the daily reports is adjusted based on the results of the emotion analysis.

[1720] Natural language explanations

[1721] The server automatically generates the contents of the daily report based on the task information in the database and the results of emotion analysis, so that the user's mood and emotions are reflected in the daily report.

[1722] Specific examples

[1723] When generating a daily report for user "Yamada Taro," the server generates a daily report with content such as "Today, we progressed with the design review. It is progressing smoothly and I am very satisfied." based on task information (e.g., "Design review, in progress, 5 hours of work") and emotion analysis results (e.g., "Delighted").

[1724] 5. Saving daily reports

[1725] The server saves the generated daily reports in a predetermined format, which allows the daily reports to be saved in a unified format.

[1726] Natural language explanations

[1727] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format), so that the daily reports are stored in a unified format.

[1728] Specific examples

[1729] Save the generated daily report in a format such as "2023-10-05_Yamada Taro_DailyReport.md".

[1730] 6. Generate weekly reports

[1731] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database, and also takes into account the results of sentiment analysis.

[1732] Natural language explanations

[1733] The server automatically generates a weekly report summarizing the progress of a specific week based on the daily report data. The results of sentiment analysis are also reflected in the weekly report.

[1734] Specific examples

[1735] A weekly report is generated based on task information for the specified week (e.g., "5 completed tasks, 2 incomplete tasks") and sentiment analysis results (e.g., "Overall satisfaction was high this week").

[1736] 7. Saving weekly reports

[1737] The server saves the generated weekly reports in a predetermined format, which allows the weekly reports to be saved in a unified format.

[1738] Natural language explanations

[1739] The server saves the generated weekly reports in a specific folder in a specified format, so that the weekly reports are stored in a unified format.

[1740] Specific examples

[1741] Save the generated weekly report in the format "2023-10-01_To_2023-10-07_WeeklyReport.md".

[1742] The above is a specific embodiment of the present invention. By combining it with an emotion engine, it is possible to realize an advanced reporting system that not only manages tasks and reports progress, but also takes into account the emotions of users. This allows reports to be created that reflect the moods and motivations of employees, which is expected to improve the performance of the entire company.

[1743] The processing flow will be explained below.

[1744] Step 1:

[1745] The server sends a request to the API endpoint of the external system to obtain the required task information.

[1746] Specific actions

[1747] The server configures the API endpoint of the external system, along with the necessary query parameters and authentication information, and sends an API request to retrieve project and task information (e.g., task name, assignee, status, start date, end date, etc.).

[1748] python

[1749] url = "https: / / external-system.com / api / tasks"

[1750] params = {'project_id': 'ABC123'}

[1751] headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}

[1752] response = requests.get(url, params=params, headers=headers)

[1753] Step 2:

[1754] The server analyzes the response received from the external system and extracts the required information.

[1755] Specific actions

[1756] The server parses the API response in JSON format and extracts the required fields (e.g. task ID, name, assignee, status, time log, etc.) This data is either kept temporarily in memory for further processing or stored immediately in a database.

[1757] python

[1758] if response.status_code == 200:

[1759] tasks = response.json()

[1760] for task in tasks:

[1761] task_id = task['id']

[1762] task_name = task['name']

[1763] assignee = task['assignee']

[1764] status = task['status']

[1765] Processing to save to the database

[1766] Step 3:

[1767] The server stores the analyzed task information in a database.

[1768] Specific actions

[1769] The server saves the extracted task information to the appropriate table in the database by inserting each field (task ID, name, assignee, status, time log, etc.) into the corresponding column in the database.

[1770] python

[1771] def save_to_database(task):

[1772] connection = get_database_connection()

[1773] cursor = connection.cursor()

[1774] insert_query = """INSERT INTO tasks (task_id, name, assignee, status, time_log) VALUES (%s, %s, %s, %s, %s)"""

[1775] cursor.execute(insert_query, (task['id'], task['name'], task['assignee'], task['status'], task['time_log']))

[1776] connection.commit()

[1777] cursor.close()

[1778] connection.close()

[1779] Step 4:

[1780] The device receives the user's voice input and camera footage and sends them to an emotion recognition engine.

[1781] Specific actions

[1782] The device receives voice input from the user and camera footage in real time and sends the voice and image data to the emotion recognition engine.

[1783] python

[1784] def capture_user_input():

[1785] audio_data = record_audio()

[1786] video_data = capture_video()

[1787] return audio_data, video_data

[1788] Step 5:

[1789] The emotion recognition engine analyzes voice input and camera footage to recognize the user's emotions.

[1790] Specific actions

[1791] The emotion recognition engine analyzes the acquired voice and image data to recognize the user's emotions (e.g., joy, sadness, anger, etc.). The analysis results are sent to the server.

[1792] python

[1793] def analyze_emotion(audio_data, video_data):

[1794] emotion_results = emotion_engine.process(audio_data, video_data)

[1795] return emotion_results

[1796] Step 6:

[1797] The server stores the emotion recognition results in a database.

[1798] Specific actions

[1799] The server stores the analysis results (e.g., type and intensity of emotion) received from the emotion recognition engine in an appropriate table in the database.

[1800] python

[1801] def save_emotion_to_database(employee_id, emotion_results):

[1802] connection = get_database_connection()

[1803] cursor = connection.cursor()

[1804] insert_query = """INSERT INTO emotions (employee_id, emotion, intensity) VALUES (%s, %s, %s)"""

[1805] cursor.execute(insert_query, (employee_id, emotion_results['emotion'], emotion_results['intensity']))

[1806] connection.commit()

[1807] cursor.close()

[1808] connection.close()

[1809] Step 7:

[1810] The server retrieves task information and emotion recognition results for each employee from the database and generates a daily report.

[1811] Specific actions

[1812] The server issues a query to retrieve task information and emotion recognition results from the database for each employee, and automatically generates a daily report based on that information. The generated report includes information such as task name, person in charge, status, working time, and type and intensity of emotion.

[1813] python

[1814] employee_id = "yamada_taro"

[1815] tasks = get_tasks(employee_id)

[1816] emotions = get_emotions(employee_id)

[1817] daily_report = f"""

[1818] Daily report for {datetime.now().date()}

[1819] task

[1820] {tasks}

[1821] emotions

[1822] {emotions}

[1823] """

[1824] Step 8:

[1825] The server saves the generated daily report in a specified format.

[1826] Specific actions

[1827] The server saves the generated daily reports in a specific folder in a specified format (e.g., Markdown format, Excel format). This operation ensures that the daily reports are stored in a unified format, making them easier to refer to later.

[1828] python

[1829] with open(f" / path / to / reports / {employee_id}_daily_report.txt", "w") as file:

[1830] file.write(daily_report)

[1831] Step 9:

[1832] The server automatically generates a weekly report based on the daily report.

[1833] Specific actions

[1834] The server aggregates the daily report data stored in the database and generates a weekly report that reflects the progress and sentiment analysis results for the week. The weekly report includes the progress of each task, the number of completed tasks, the number of incomplete tasks, and an overview of the user's sentiment.

[1835] python

[1836] week_start = "2023-10-01"

[1837] week_end = "2023-10-07"

[1838] weekly_reports = get_weekly_reports(week_start, week_end)

[1839] weekly_report = f"""

[1840] Weekly report from {week_start} to {week_end}

[1841] {weekly_reports}

[1842] """

[1843] Step 10:

[1844] The server saves the generated weekly report in a specified format.

[1845] Specific actions

[1846] The server saves the generated weekly reports in a specific folder in a specified format. This operation ensures that the weekly reports are stored in a standardized format, making it easier to manage the progress of the entire project.

[1847] python

[1848] with open(" / path / to / reports / weekly_report.txt", "w") as file:

[1849] file.write(weekly_report)

[1850] These are the specific processing steps of the present invention. By combining it with an emotion engine, it is possible to realize an advanced reporting system that not only manages tasks and reports progress, but also takes into account the emotions of users. This allows reports to be created that reflect the moods and motivations of employees, which is expected to improve the performance of the entire company.

[1851] Example 2

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

[1853] In today's work environment, task management and progress reporting are important, but one-way reporting systems that don't take into account employee emotions and motivation have limitations in improving work efficiency and employee satisfaction. Furthermore, manually creating daily and weekly reports is time-consuming and labor-intensive, making them inefficient. To solve these problems, a reporting system that combines automatic task information acquisition and emotion analysis is needed.

[1854] 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 acquiring task information from an external system, a means for storing the acquired task information in a database, a sentiment analysis means for analyzing the user's sentiment, a means for creating a daily report based on the information in the database and the sentiment analysis results, and a means for saving the daily report in a predetermined format. This makes it possible to automatically generate a report that integrates task information and sentiment information, thereby realizing advanced task management and progress reporting that reflects the sentiments of employees.

[1855] An "external system" is a system that provides task information, such as a project management tool or a task management tool.

[1856] "Task information" is a series of information about a task, such as the task name, person in charge, status, start date, and end date.

[1857] A "database" is a data storage system that stores acquired task information and enables quick reference to data required for subsequent processing.

[1858] The "emotion analysis means" is a system that analyzes the user's voice input and facial recognition data, and identifies the user's emotions as labels such as "joy," "sadness," and "anger."

[1859] A "daily report" is a report summarizing daily work and progress based on database information and sentiment analysis results.

[1860] A "weekly report" is a report that summarizes progress on a weekly basis based on daily reports.

[1861] A "prescribed format" is a standardized file format that ensures reports are saved in a consistent format, including Markdown and Excel formats.

[1862] This invention is a system that acquires task information from an external system, stores it in a database, and then analyzes user emotions to automatically generate daily and weekly reports. This system is implemented mainly with the cooperation of a server, terminals, and users.

[1863] Hardware and Software Configuration

[1864] The server connects to external systems via an application programming interface (API) for communicating with project management tools and task management tools. The server also requires a database connection driver such as ODBC or JDBC to store the acquired task information in a database. Programming languages ​​and libraries such as Python or Java are also used to generate daily and weekly reports using sentiment analysis and generative AI models.

[1865] The device has hardware and software to capture user voice input and camera footage and send it to an emotion analysis engine, including a microphone, camera, and voice and facial recognition software.

[1866] The user uses a terminal to input data (audio, video, etc.) for the daily report. The audio and video data input by the user is sent to the emotion analysis engine via the terminal.

[1867] Specific operation of the system

[1868] 1. Get task information

[1869] The server sends an HTTP request to the API of the external system to obtain task information. The obtained information is received in JSON format and parsed. For example, obtain task information for "Project XYZ" from a project management tool.

[1870] 2. Storage in the database

[1871] The server uses SQL INSERT and UPDATE statements to store the retrieved task information in the database, so that the task information is saved in the database and can be quickly referenced at any time.

[1872] 3. Emotion analysis

[1873] The device receives voice input and camera footage from the user and sends it to an emotion analysis engine. The analysis engine analyzes the audio and video data and identifies the user's emotion as a label such as "happiness," "sadness," or "anger." For example, if a user says to the device, "Today's meeting was very constructive," the emotion engine will interpret it as "happiness."

[1874] 4. Generate daily and weekly reports

[1875] The server generates a daily report based on task information retrieved from the database and the results of sentiment analysis. A generative AI model is used in this process. A prompt such as "Please generate a daily report based on today's work content and emotions" is sent to the model. The generated daily report is saved in a specified format such as Markdown or Excel.

[1876] 5. Saving and Referencing

[1877] Daily reports are saved in a specific folder by the server, and weekly reports are saved in the same way. For example, the daily report is saved as "2023-10-05_EmployeeA_DailyReport.md" and the weekly report is saved as "2023-10-01_To_2023-10-07_WeeklyReport.md".

[1878] In this way, by automatically generating reports that integrate task information and emotional information, it is possible to achieve advanced task management and progress reports that reflect employees' emotions, enabling effective business operations that take into account employees' moods and motivations.

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

[1880] Step 1:

[1881] The server obtains task information from an external system. Specifically, the server sends an HTTP GET request to the external system's API and receives task information in JSON format. The input is the API request parameters (e.g., project ID), and the output is the JSON-formatted task information received as a response. The server parses this task information and extracts the necessary data items (e.g., task name, assignee, status, start date, and end date).

[1882] Step 2:

[1883] The server stores the extracted task information in a database. The input is the extracted task information, and the output is the newly added or updated data in the database. Specifically, the server generates SQL INSERT or UPDATE statements and executes them against the database via ODBC or JDBC. This saves the task information in the database.

[1884] Step 3:

[1885] The device receives voice input and camera footage from the user and prepares it as data for emotion analysis. The input is the user's voice and video data, and the output is data converted into the format required for analysis. Specifically, the device sends the data acquired by the microphone and camera to the emotion analysis engine in real time.

[1886] Step 4:

[1887] The server receives the emotion data analyzed by the emotion analysis engine and uses it as data for generating daily reports. The input is the analyzed emotion data (e.g., "joy," "sadness," "anger"), and the output is daily report data that combines this emotion data with task information. Specifically, the server integrates the emotion data with task information and sends prompt sentences to the generative AI model.

[1888] Step 5:

[1889] The generative AI model generates daily reports based on prompts received from the server. The input is data (task information and emotion data) integrated with the prompt, and the output is the generated daily report text. Specifically, a prompt such as "Please generate a daily report based on today's work content and emotions" is input into the model, and the generated daily report text is obtained.

[1890] Step 6:

[1891] The server saves the generated daily report in a specified format (e.g., Markdown format, Excel format). The input is the generated daily report text, and the output is a daily report file saved in the specified file format. Specifically, the content of the daily report is converted to Markdown or Excel format and saved in the file system.

[1892] Step 7:

[1893] The server retrieves one week's worth of daily report data from the database and automatically generates a weekly report based on this. The input is the daily report data, and the output is the generated weekly report text. Specifically, the server aggregates the daily report data and sends a prompt message to the generative AI model saying, "Please generate a weekly report based on the work content and emotions of the past week," to generate the weekly report.

[1894] Step 8:

[1895] The server saves the generated weekly report in a specified format. The input is the generated weekly report text, and the output is a weekly report file saved in a specified file format. Specifically, the contents of the weekly report are converted to Markdown or Excel format and saved in the file system.

[1896] (Application example 2)

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

[1898] In conventional factory environments, worker task management and progress reporting are often done manually, resulting in reduced efficiency. Furthermore, because the emotions and motivation of workers are not taken into account, this can have a negative impact on work efficiency and safety. Therefore, there is a need for a system that integrates task management and emotion recognition to provide efficient and comprehensive management.

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

[1900] In this invention, the server includes means for acquiring task information from an external system, means for storing the acquired task information in a database, means for creating a daily report based on the information in the database, means for saving the daily report in a predetermined format, means for acquiring a user's voice input or facial recognition data and analyzing their emotions, and means for adjusting the content of the daily report based on the emotion analysis results. This enables integrated management of the task progress and emotional state of workers, enabling efficient work instructions and appropriate motivation management.

[1901] An "external system" is a system that allows factory robots and workers to obtain information from task management tools, databases, etc.

[1902] "Task information" is information such as the name of the work to be performed in the factory, the person in charge, the status, the start date, and the end date.

[1903] A "database" is an information management system that stores acquired task information and facilitates search and extraction.

[1904] A "daily report" is a report used to record and store the progress of work and emotional state of the day.

[1905] A "weekly report" is a report summarizing work progress and emotional state for a particular week.

[1906] "Emotion analysis" is the process of identifying and analyzing a user's emotional state based on their voice input and facial recognition data.

[1907] The "emotion engine" is a software component that analyzes voice input and facial recognition data to classify the user's emotions into categories such as "joy," "sadness," and "anger."

[1908] A "server" is a computer system that acquires data from external systems, stores it in a database, and generates and saves daily and weekly reports.

[1909] "Voice input" is an interface where a user provides data to a system using their voice.

[1910] "Facial recognition data" refers to image data of a user's face acquired using a device such as a camera.

[1911] The "prescribed format" refers to a standardized format in which daily and weekly reports are saved, such as Markdown format or Excel format.

[1912] MODE FOR CARRYING OUT THE INVENTION

[1913] The present invention is a system that integrates task management and emotion recognition for workers in a factory. Hereinafter, an embodiment of the present invention will be described in detail.

[1914] 1. Obtaining task information from an external system

[1915] The server sends a request to an external system (e.g., a task management tool) via an application programming interface (API) to obtain the required task information, including the task name, person in charge, status, start date, end date, etc. The obtained task information is stored in a database by the server.

[1916] 2. Storing task information in a database

[1917] The server stores the task information obtained from the external system in a database. This operation establishes data storage that can be quickly referenced in subsequent processes. In addition to task information, the database also stores worker emotion data.

[1918] 3. Emotion Recognition by Emotion Engine

[1919] The device receives voice input and facial recognition data from the user. This data is analyzed by an emotion engine, which classifies the user's emotions into categories such as "happiness," "sadness," and "anger." The analysis results are stored in a database and reflected in the content of daily and weekly reports.

[1920] 4. Generate daily reports

[1921] The server automatically generates daily reports for each worker based on task information retrieved from the database and the results of the emotion engine's analysis. The content of the daily reports is adjusted based on the results of the emotion analysis.

[1922] 5. Saving daily reports

[1923] The server saves the generated daily reports in a specified format (for example, Markdown or Excel format). This format ensures that the daily reports are stored in a unified format.

[1924] 6. Generate weekly reports

[1925] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database, and also takes into account the results of sentiment analysis.

[1926] 7. Saving weekly reports

[1927] The server saves the generated weekly reports in a specified format, which allows the weekly reports to be stored in a unified format.

[1928] A concrete example of how this system works is the process in which a factory worker uses a smartphone to input task progress and record their emotions through voice input. For example, the worker might say, "I'm glad that work went smoothly today." This voice data is analyzed by the emotion engine and recognized as "joy." As a result, the server automatically generates a daily report based on this information, such as, "Work went smoothly today. I'm satisfied," and saves it in a specified format.

[1929] The specific hardware used includes smartphones and factory robots, the software uses Python and SQLite, and retrieves data from external systems via APIs, and an emotion engine is used for emotion analysis.

[1930] Further examples of leveraging generative AI models include prompts such as:

[1931] One day, you have to create a system for reporting work at a factory. Write a program that retrieves task information from an external task management tool, stores it in a database, and generates daily and weekly reports. You also need to incorporate a function to analyze user sentiment and reflect the results in the reports.

[1932] This type of structure allows for efficient work instructions, appropriate motivation management, and integrated task and emotion management.

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

[1934] Step 1:

[1935] Retrieving task information from an external system

[1936] The server sends an API request to an external system (such as a task management tool) to obtain the required task information. As input, the request data for the task information to be obtained (e.g., project ID and authentication information) is provided. As output, the obtained task information (e.g., task name, assignee, status, start date, end date) is obtained. This task information is passed to the server in JSON format. The server stores this information in temporary memory.

[1937] Step 2:

[1938] Storing task information in a database

[1939] The server stores the retrieved task information in a database. The task information retrieved in step 1 is used as input. The server inserts the task information into the database using an SQL query. The output is confirmation of the newly added task information in the database. This establishes data storage that can be quickly referenced in subsequent processes.

[1940] Step 3:

[1941] Emotion recognition by emotion engine

[1942] The device receives voice input or facial recognition data from the user. Inputs include voice data and camera image data provided by the user to the device. The device sends this data to the emotion engine, which analyzes the emotions. The output is analyzed emotion data (e.g., "joy," "sadness," "anger," etc.). The analyzed emotion data is registered in a database. This information is used when generating daily reports.

[1943] Step 4:

[1944] Generate daily reports

[1945] The server retrieves task information and the emotion engine's analysis results from the database and automatically generates daily reports for each user. The user's task information and emotion data are retrieved from the database as input. The server creates the text content of the daily report based on this data. The generated text data of the daily report is obtained as output. This text data is used in subsequent processing.

[1946] Step 5:

[1947] Saving daily reports

[1948] The server saves the generated daily report in a specified format (Markdown or Excel format). The input is the text data of the generated daily report. The server uses a file manipulation library to save the file in the specified format. As an output, the daily report file is saved in a specified folder. This file is referenced later.

[1949] Step 6:

[1950] Generate weekly reports

[1951] The server automatically generates a weekly report summarizing progress on a weekly basis based on the daily report information stored in the database. Daily report information for a specified week is retrieved from the database as input. The server creates the text content of the weekly report based on this data. The output is the text data of the generated weekly report.

[1952] Step 7:

[1953] Saving weekly reports

[1954] The server saves the generated weekly report in a specified format. The input is the text data of the generated weekly report. The server uses a file operation library to save the file in the specified format. As an output, the weekly report file is saved in a specified folder. This file is referenced later.

[1955] In this way, daily and weekly reports based on task information and emotion data are efficiently generated and stored.

[1956] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

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

[1959] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1960] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1961] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1962] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1963] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1964] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1965] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1966] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1967] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1968] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1969] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1970] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1971] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1972] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1973] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1974] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1975] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1976] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1977] The following is further disclosed regarding the above embodiment.

[1978] (Claim 1)

[1979] A means for obtaining task information from an external system;

[1980] A means for storing the acquired task information in a database;

[1981] A means of creating daily reports based on information from the database;

[1982] A means for saving the daily report in a predetermined format;

[1983] A system including:

[1984] (Claim 2)

[1985] 10. The system of claim 1, wherein the means for obtaining task information from an external system uses an application programming interface.

[1986] (Claim 3)

[1987] 2. The system according to claim 1, further comprising means for creating a weekly report based on the daily report.

[1988] "Example 1"

[1989] (Claim 1)

[1990] A means for obtaining task information from an external system;

[1991] A means for storing the acquired task information in a database;

[1992] A means of creating daily reports based on information from the database;

[1993] A means for saving the daily report in a predetermined format;

[1994] A means for producing weekly reports;

[1995] A system including:

[1996] (Claim 2)

[1997] 10. The system of claim 1, wherein the means for obtaining task information from an external system uses an application programming interface.

[1998] (Claim 3)

[1999] 10. The system of claim 1, further comprising: means for sending a request using an authentication token when retrieving task information.

[2000] (Claim 4)

[2001] 2. The system according to claim 1, further comprising means for parsing the acquired task information in JSON format.

[2002] (Claim 5)

[2003] 10. The system of claim 1, further comprising means for storing task information in a database using SQL statements.

[2004] (Claim 6)

[2005] 10. The system of claim 1, further comprising means for generating daily and weekly reports using a template engine.

[2006] (Claim 7)

[2007] 10. The system of claim 1, further comprising means for saving the report in Markdown or Excel format.

[2008] "Application Example 1"

[2009] (Claim 1)

[2010] A means for obtaining task information from an external system;

[2011] A means for storing the acquired task information in a database;

[2012] A means of creating daily reports based on information from the database;

[2013] A means for saving the daily report in a predetermined format;

[2014] a means for acquiring task information from a robot control system, storing the information in a database, and saving daily and weekly reports automatically generated based on the progress of the robot's work;

[2015] A means of checking task progress over a specified period using a generative AI model; and

[2016] A system including:

[2017] (Claim 2)

[2018] 10. The system of claim 1, wherein the means for obtaining task information from an external system uses an application programming interface.

[2019] (Claim 3)

[2020] 2. The system according to claim 1, further comprising means for creating a weekly report based on the daily report.

[2021] "Example 2: Combining Emotion Engines"

[2022] (Claim 1)

[2023] A means for obtaining task information from an external system;

[2024] A means for storing the acquired task information in a database;

[2025] emotion analysis means for analyzing the emotions of a user;

[2026] A means for creating daily reports based on the information in the database and the results of sentiment analysis;

[2027] A means for saving the daily report in a predetermined format;

[2028] A system including:

[2029] (Claim 2)

[2030] 10. The system of claim 1, wherein the means for obtaining task information from an external system uses an application programming interface.

[2031] (Claim 3)

[2032] 2. The system according to claim 1, further comprising means for creating a weekly report based on the daily report.

[2033] "Application example 2 when combining emotion engines"

[2034] (Claim 1)

[2035] A means for obtaining task information from an external system;

[2036] A means for storing the acquired task information in a database;

[2037] A means of creating daily reports based on information from the database;

[2038] A means for saving the daily report in a predetermined format;

[2039] a means for acquiring voice input or facial recognition data of a user and analyzing emotions;

[2040] A means to adjust the content of daily reports based on the results of sentiment analysis;

[2041] A system including:

[2042] (Claim 2)

[2043] 10. The system of claim 1, wherein the means for obtaining task information from an external system uses an application programming interface.

[2044] (Claim 3)

[2045] 2. The system according to claim 1, further comprising means for creating a weekly report based on the daily report. [Explanation of symbols]

[2046] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for obtaining task information from an external system; A means for storing the acquired task information in a database; A means of creating daily reports based on information from the database; A means for saving the daily report in a predetermined format; A system including:

2. 2. The system of claim 1, wherein the means for obtaining task information from an external system uses an application programming interface.

3. 2. The system according to claim 1, further comprising means for generating a weekly report based on the daily report.

Images