System

Abstract

A system is provided.SOLUTION: A system comprising: means for collecting accident data; means for analyzing the accident data and extracting causes and measures of the accident; means for automatically generating learning contents based on the extracted causes and measures; means for automatically generating test questions for testing understanding levels based on the learning contents; means for automatically distributing the automatically generated learning contents and test questions to relevant users; means for performing learning and testing by the users; and means for collecting and evaluating test results of the users.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 large development organizations, knowledge sharing is not carried out smoothly, and accidents with the same causes often occur again. The main reason for this is that knowledge sharing takes a great deal of time and effort, so there is a need for fast and efficient knowledge sharing and learning. The objective of this invention is to improve the efficiency of knowledge sharing and learning, thereby accumulating knowledge in the case of serious accidents and preventing their recurrence. [Means for solving the problem]

[0005] The present invention provides a system that includes means for collecting accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to relevant users, means for users to study and test, and means for collecting and evaluating users' test results. This system allows knowledge about serious accidents to be accumulated and shared quickly and efficiently, and measures to prevent recurrence to be implemented effectively and widely.

[0006] "Accident data" refers to data that includes information on the details, causes, effects, and countermeasures of an accident.

[0007] "Collection means" refers to the software and hardware components for collecting accident data.

[0008] "Means of analysis" is a general term for algorithms and tools used to analyze collected accident data and extract causes and countermeasures.

[0009] "Means for automatic generation" refers to technical means for automatically creating learning content and test questions using generative AI models.

[0010] "Learning content" refers to educational materials that provide learners with information about the causes of accidents and countermeasures.

[0011] A "test question" is a test question used to assess a learner's comprehension.

[0012] "Means for automatic distribution" refers to a mechanism for automatically distributing the generated learning content and test questions to relevant users.

[0013] "User" refers to the user of the system who inputs accident data, views learning content, and answers test questions.

[0014] "Evaluation methods" are tools and algorithms used to collect and evaluate the results of user-administered tests.

[0015] A "natural language processing model" is a machine learning model used to analyze text data and extract the causes of accidents and countermeasures.

[0016] A "generative AI model" is an artificial intelligence model for automatically generating learning content and test questions.

[0017] "Database" means a system for storing and managing collected accident data. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0026] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0039] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in large development organizations. Below, we will explain the program processing of this system in natural language, and provide concrete examples.

[0040] System Overview

[0041] This system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users, thereby quickly sharing knowledge for accident prevention. The entire system is mainly composed of a server, terminals, and users.

[0042] Accident data collection

[0043] 1. When an accident occurs, the user enters the accident data into a form for entering details of the accident. The accident data includes the date and time of the accident, the extent of the impact, the cause, specific details of the problem, and countermeasures.

[0044] 2. The terminal checks the format of the entered accident data and performs error checking to notify of input errors if necessary.

[0045] 3. The server stores the correctly formatted accident data in a database for later analysis.

[0046] Analysis of the accident

[0047] 1. The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, thereby extracting the causes of the accident and countermeasures.

[0048] 2. The server uses a clustering algorithm to group accident data with similar causes and countermeasures and organize the analysis results.

[0049] Automatic generation of learning content and test questions

[0050] 1. The server uses a generative AI model to automatically generate learning content from the analysis results, including text, diagrams, and checklists, with detailed explanations of specific examples and countermeasures.

[0051] 2. The server then automatically generates test questions based on the generated learning content to test comprehension, including multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[0052] Automatic sharing and notifications

[0053] 1. The server automatically distributes the generated learning content and test questions to a list of relevant users via an internal messaging system or email.

[0054] 2. The device sends a notification to the user so that they can access the delivered learning content and test questions.

[0055] Study and test

[0056] 1. Users receive a notification and can view the learning content on their device. The learning content can be easily accessed through a web browser or dedicated application.

[0057] 2. After studying, the user answers test questions on their device. The test results are sent to the server in real time.

[0058] Test result evaluation and follow-up

[0059] 1. The server aggregates the received test results and evaluates each user's level of understanding. The results are displayed on a dashboard so that administrators can check their progress.

[0060] 2. The server will then provide instructions for follow-up study as needed, and may automatically notify students of retests or additional assignments.

[0061] Specific examples

[0062] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. Next, the server uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and takes the test, and their level of understanding is evaluated. Based on the results of the evaluation, the server notifies them of additional learning as necessary.

[0063] This will enable efficient sharing of knowledge and effectively prevent accidents from occurring again.

[0064] The processing flow will be explained below.

[0065] Step 1:

[0066] When an accident occurs, users enter a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The form includes detailed information such as the date and time of the accident, the names of the affected systems and modules, specific details of the problem, and the time until recovery.

[0067] Step 2:

[0068] The terminal checks the entered accident data to see if there are any errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[0069] Step 3:

[0070] The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[0071] Step 4:

[0072] The server runs a natural language processing (NLP) model to analyze the stored accident data, extracting causes and effects from the text data and identifying relevant keywords.

[0073] Step 5:

[0074] Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of accidents, which allows accidents with similar causes and countermeasures to be grouped together and classified.

[0075] Step 6:

[0076] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures, including text, diagrams, and checklists related to the causes of accidents and countermeasures.

[0077] Step 7:

[0078] The server automatically generates test questions based on the learning content, including multiple choice, word fill-in-the-blank, and question-and-answer formats, that match the generated content.

[0079] Step 8:

[0080] The server automatically distributes the generated learning content and test questions to relevant users, including departments affected by the incident and members of related teams.

[0081] Step 9:

[0082] The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[0083] Step 10:

[0084] Users receive notifications and can view the learning content through a web interface or dedicated application on their device. The learning content is easily accessible and intuitive to use.

[0085] Step 11:

[0086] After studying, users answer test questions on their devices, and the answers are sent to the server in real time.

[0087] Step 12:

[0088] The server aggregates the received test results and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard and can be checked by an administrator.

[0089] Step 13:

[0090] The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even if the user's understanding is insufficient.

[0091] Example 1

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

[0093] When an accident occurs in a large development organization, it is necessary to quickly and effectively share the cause and countermeasures. However, with conventional methods, collecting and analyzing accident data takes time, which often delays the sharing of knowledge. In addition, manually creating learning content and test questions requires a great deal of effort, resulting in a decrease in the effectiveness of education. A system is needed to solve these issues and efficiently prevent accidents and share knowledge.

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

[0095] In this invention, the server includes means for collecting accident data, means for checking the format of the collected accident data and notifying of input errors, means for analyzing the accident data to extract causes of the accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to relevant users, means for users to study and test, means for collecting and evaluating user test results, and means for instructing additional follow-up study based on the evaluation results. This enables the entire process from collecting accident data to automatically generating, distributing, and evaluating learning content and test questions to be carried out efficiently.

[0096] "Accident data" is data collected when an accident occurs, including information such as the date and time of the accident, the extent of the impact, the cause, the specific details of the problem, and countermeasures.

[0097] The "means of collection" refers to the means by which accident data is input by users and then imported into the system.

[0098] The "means for checking the format and notifying of input errors" refers to a means for checking whether the values ​​in each field of the collected accident data are in the appropriate format, and for prompting the user to re-enter the data if there is an error.

[0099] "Means of analyzing and extracting the causes of accidents and countermeasures" refers to analyzing collected accident data using natural language processing models, etc., and extracting the causes of accidents and countermeasures.

[0100] "Means for automatically generating learning content" refers to a means for automatically generating content (text, illustrations, checklists, etc.) for users to study based on the analysis results using a generative AI model.

[0101] "Means for automatically generating test questions to test comprehension" refers to a means for automatically generating test questions (multiple choice questions, fill-in-the-blank questions, question-and-answer questions, etc.) to evaluate a user's level of comprehension based on the generated learning content.

[0102] The "means for automatically distributing automatically generated learning content and test questions to relevant users" refers to a means for automatically distributing the generated learning content and test questions to relevant users.

[0103] "Means for learning and testing" refers to the means by which a user can view learning content and answer test questions.

[0104] The "means for collecting and evaluating test results" refers to a means for aggregating test results sent by users and evaluating the level of understanding of each user.

[0105] The "means for instructing additional follow-up study" refers to a means for instructing the user on necessary additional study based on the evaluation of the test results, and for notifying the user of retests or additional assignments.

[0106] This invention is a system for efficiently preventing accidents and sharing knowledge in large development organizations. This system collects and analyzes accident data, automatically generates learning content and test questions based on the data, and distributes them to users, thereby quickly sharing knowledge for preventing accidents. The entire system is mainly composed of a server, terminals, and users.

[0107] An embodiment of the system will now be described in detail.

[0108] First, when an accident occurs, the user accesses a dedicated form and enters the accident data (date and time of occurrence, extent of impact, cause, specific details of the failure, countermeasures, etc.). For example, this can be done using a web browser. After the user has completed the input, they press the send button, which sends the data to the server.

[0109] The terminal receives this data and performs a format check. For example, it checks whether the date and time information is in the "YYYY-MM-DD" format. If there is an error in the input, it displays an error message to the user and prompts them to re-enter the information.

[0110] The server stores the correct formatted accident data sent from the device in a database (for example, MySQL) for later analysis.

[0111] The server retrieves accident data from the database and analyzes the text data using a natural language processing (NLP) model (e.g., BERT), thereby extracting the causes of the accident and countermeasures.

[0112] The server then uses a clustering algorithm (e.g., K-means) to group incident data with the same causes and countermeasures, making it easier to identify similar patterns.

[0113] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content from the analysis results. For example, it generates learning materials such as best practices and checklists for the extracted "lack of review." The server then automatically generates test questions (multiple choice questions, fill-in-the-blank questions, question-and-answer questions, etc.) to test comprehension based on the generated learning content.

[0114] The server automatically distributes these learning contents and test questions to relevant users, for example, via an internal messaging system (e.g., Slack) or email.

[0115] The device notifies the user when new learning content and test questions have been distributed. The user receives the notification and accesses the learning content from their device (PC or smartphone). The learning content can be easily accessed through a web browser or dedicated application.

[0116] Users study the content and answer test questions. The test results are sent in real time to the server, which then aggregates them and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard, allowing administrators to monitor progress.

[0117] Based on the evaluation results, the server automatically recommends additional follow-up learning, and will also notify students of retests or additional assignments as necessary.

[0118] As a specific example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident. The device performs a format check and, if no errors are found, sends the data to the server. The server uses a natural language processing model to identify "insufficient reviews" as the cause and "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the devices of the relevant developers, and the users study and take the test, with their level of understanding being evaluated by the server. Depending on the evaluation results, the server notifies them of additional learning as necessary.

[0119] An example of a prompt is, "Please explain the cause and solution of a system outage that occurred in a certain development team. Also, please generate appropriate learning content and test questions based on that." This system will enable efficient knowledge sharing and the prevention of accident recurrence.

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

[0121] Step 1:

[0122] When an accident occurs, the user accesses a dedicated form and enters the accident data (date and time of occurrence, extent of impact, cause, specific details of the problem, countermeasures, etc.). After completing the input, the user clicks the send button.

[0123] Input: Accident data (occurrence date and time, extent of impact, cause, specific details of the failure, countermeasures)

[0124] Output: Accident data entered into the form

[0125] Step 2:

[0126] The terminal receives the transmitted accident data and performs format checks, for example, checking that the date field is in "YYYY-MM-DD" format, and if there is an error, it displays an error message to the user and asks them to re-enter the data.

[0127] Input: Accident data submitted via the form

[0128] Output: Correctly formatted incident data or an error message

[0129] Step 3:

[0130] The server stores the correct formatted accident data sent from the device in a database (e.g., MySQL).

[0131] Input: Accident data that passes format check

[0132] Output: Accident data stored in a database

[0133] Step 4:

[0134] The server retrieves accident data from the database, analyzes the text data using a natural language processing (NLP) model (e.g., BERT), and extracts the causes of the accident and countermeasures.

[0135] Input: Accident data retrieved from the database

[0136] Output: Extracted causes of accidents and countermeasures

[0137] Step 5:

[0138] The server uses a clustering algorithm (e.g., K-means) to group similar data based on the analyzed causes and countermeasures of the accident.

[0139] Input: Extracted cause and countermeasure data

[0140] Output: Clustered accident data

[0141] Step 6:

[0142] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content from the clustering results, such as best practices for review gaps and checklists to prevent similar incidents from occurring.

[0143] Input: Clustering results

[0144] Output: Auto-generated learning content

[0145] Step 7:

[0146] The server automatically generates test questions to assess comprehension based on the generated learning content, including multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[0147] Input: Learning content

[0148] Output: Auto-generated test questions

[0149] Step 8:

[0150] The server automatically distributes the generated learning content and test questions to relevant users, for example, via an internal messaging system (e.g., Slack) or email.

[0151] Input: Learning content and test questions

[0152] Output: Delivery notification to user

[0153] Step 9:

[0154] The device will notify the user when new learning content and test questions are available via pop-ups, push notifications, emails, etc.

[0155] Input: Delivery notification from the server

[0156] Output: A message to inform the user

[0157] Step 10:

[0158] Users receive a notification and can access the learning content from their device (PC or smartphone) via a web browser or dedicated application.

[0159] Input: Delivered learning content

[0160] Output: User learning activity

[0161] Step 11:

[0162] After studying, users answer test questions using their devices, and the test results are sent to the server in real time.

[0163] Input: Answer to test question

[0164] Output: Test results sent in real time

[0165] Step 12:

[0166] The server aggregates the received test results and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard so that administrators can check their progress.

[0167] Input: Test result data

[0168] Output: Aggregated evaluation results and dashboard display

[0169] Step 13:

[0170] Based on the evaluation results, the server automatically recommends additional follow-up learning as needed, and also notifies students of retests and additional assignments.

[0171] Input: Aggregated evaluation results

[0172] Output: Notifications for follow-up study and retesting

[0173] (Application example 1)

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

[0175] Accidents in factories threaten the safety of workers and reduce productivity. Conventional systems tend to be slow to share knowledge to prevent accidents, and preventive measures are not quickly implemented. For this reason, there is a need for a system that can quickly and efficiently collect and analyze accident data, automatically generate appropriate learning content and test questions based on that data, and quickly share them with workers and robots.

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

[0177] In this invention, the server includes means for collecting accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to related workers and robots, means for workers to study and test, and means for collecting and evaluating test results. This allows knowledge on accident prevention to be shared quickly and efficiently, making it possible to prevent accidents from recurring at factory sites.

[0178] "Accident data" refers to detailed information about accidents that occur within a factory, including the date and time of the accident, the extent of the impact, the cause, the specific details of the problem, and countermeasures.

[0179] A "natural language processing model" refers to algorithms and techniques that allow computers to understand, analyze, and generate human language, providing a means of extracting meaning and context from text.

[0180] A "generative AI model" is an algorithm that uses machine learning to automatically generate new content and data, generating text, images, audio, etc. based on given input.

[0181] "Learning content" refers to learning materials for acquiring specific knowledge or skills, and includes text, illustrations, checklists, etc.

[0182] "Test questions" are questions or tasks used to assess a user's understanding of the learning content, and may include multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[0183] A "robot" is a mechanical device that automatically performs specific tasks or operations in a factory, helping to prevent accidents and share knowledge.

[0184] The "Factory Robot Support System" is an integrated system for collecting and analyzing accident data, generating and distributing learning content, generating test questions, and providing these to workers and robots.

[0185] As an embodiment of the present invention, the following factory robot support system is provided. The entire system is mainly composed of a server, terminals, and users (workers and robots). How each component of the system interacts and functions will be explained below.

[0186] System Overview

[0187] This factory robot support system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users and robots, thereby quickly sharing knowledge to prevent accidents.

[0188] Hardware and Software

[0189] Hardware

[0190] Factory robot: A device with an interface that allows workers to easily input accident data and share knowledge about accident prevention.

[0191] Server: Provides infrastructure for database management, natural language processing analysis, and generative AI model operation.

[0192] software

[0193] Natural language processing (NLP) engine: Used to analyze text data, and specific technologies include models such as BERT and GPT-3.

[0194] Clustering algorithms: Used to group accident data with similar causes and countermeasures, specific techniques include k-means.

[0195] Generative AI models: Used to automatically generate learning content and test questions; specific technologies include OpenAI's GPT-3.

[0196] Program processing explanation

[0197] 1. Entering accident data and checking for errors

[0198] When an accident occurs, the user inputs details of the accident into a terminal built into the factory robot, which then checks the input data for incomplete data or input errors.

[0199] 2. Accident data storage

[0200] Correctly formatted accident data is sent to a server and stored in a database for later analysis.

[0201] 3. Analysis of the accident

[0202] The server retrieves the accident data from the database, performs text analysis using natural language processing techniques (e.g., BERT or GPT-3), and then groups the accident data using a clustering algorithm (e.g., k-means).

[0203] 4. Automatic generation of learning content and test questions

[0204] Generative AI models (e.g., GPT-3) are used to generate learning content from the analysis results, including text, diagrams, checklists, etc. Test questions are also automatically generated to test comprehension.

[0205] 5. Delivery and Notification

[0206] The generated learning content and test questions are automatically distributed by the server to the relevant workers and robots via the factory messaging system or email, and notifications are sent by the terminals.

[0207] 6. Implementation of learning

[0208] The worker receives a notification and views the learning content on their device. After studying, they take a test, and the test results are sent to the server in real time.

[0209] 7. Evaluation and follow-up of test results

[0210] The server aggregates the received test results and evaluates each worker's level of understanding. The results are displayed on a dashboard, allowing managers to check progress and, if necessary, instruct additional follow-up learning.

[0211] Specific examples

[0212] For example, if a collision occurs while operating a forklift in a factory, the worker uses the robot's interface to input details of the accident. The server analyzes this data, identifies "misoperation of the forklift" as the cause, and extracts "improvement of operating techniques" as the countermeasure. Next, it uses a generative AI model to generate learning content on "safe forklift operation methods" and test questions on "risks caused by operating errors." These content and test questions are then distributed to the relevant workers and robots.

[0213] Example prompt for a generative AI model:

[0214] "Please create learning content that instructs students on how to improve their driving techniques regarding collision accidents that occurred due to forklift driving errors, and create test questions to measure their understanding."

[0215] This will enable accident prevention knowledge to be shared effectively within the factory, preventing recurrence.

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

[0217] Step 1: Enter accident data and check for errors

[0218] The user inputs details of the accident into a terminal built into the factory robot. The terminal receives the input accident data (date and time of occurrence, extent of impact, cause, specific details of the problem, and countermeasures) and checks for incomplete data or input errors. For example, if the date and time are inaccurate, a warning is displayed, prompting correction.

[0219] Input: Accident details

[0220] Output: Well-formatted incident data or error messages

[0221] Step 2: Save the incident data

[0222] Accident data in the correct format is sent from the device to the server, which then stores the received data in a database for later analysis.

[0223] Input: Correctly formatted accident data

[0224] Output: Accident data stored in a database

[0225] Step 3: Analysis of the accident

[0226] The server retrieves accident data from the database, performs text analysis using natural language processing techniques (e.g., BERT or GPT-3) to extract accident causes and countermeasures, and then uses a clustering algorithm (e.g., k-means) to group accident data with similar causes and countermeasures.

[0227] Input: Accident data retrieved from the database

[0228] Output: Analysis results (causes of accidents and countermeasures), grouped accident data

[0229] Step 4: Automatic generation of learning content and test questions

[0230] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content based on the causes and countermeasures of accidents. This content includes text, diagrams, checklists, etc. At the same time, test questions are automatically generated to test comprehension.

[0231] Input: Analysis results (cause of accident and countermeasures)

[0232] Output: Auto-generated learning content, test questions

[0233] Step 5: Delivery and Notification

[0234] The server automatically distributes the generated learning content and test questions to the relevant workers and robots via the factory's messaging system or email, and the terminals send notifications. Specifically, each worker receives a notification message containing a link to the content.

[0235] Input: learning content, test questions

[0236] Output: Auto-distributed content and notification messages

[0237] Step 6: Learning

[0238] The user receives a notification and views the learning content on their device. After viewing the learning content, the worker answers the test questions on their device. The test results are sent to the server in real time.

[0239] Input: learning content, test questions

[0240] Output: Answered test results (sent in real time)

[0241] Step 7: Evaluate and follow up on test results

[0242] The server aggregates the received test results and evaluates each user's level of understanding. The results are displayed on a dashboard so administrators can check progress and automatically recommend additional follow-up learning if necessary.

[0243] Input: Test result

[0244] Output: Assessment results, dashboard display, and instructions for further follow-up

[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 for preventing accidents and improving the efficiency of knowledge sharing in large development organizations, and by combining it with user emotion recognition, it improves the effectiveness of the learning process. Below, we will explain the program processing of this system in natural language, and provide concrete examples.

[0247] System Overview

[0248] This system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users, quickly sharing knowledge for accident prevention. It also uses an emotion engine to recognize user emotions and improve the effectiveness of the learning content and tests. The entire system is primarily composed of a server, terminals, and users.

[0249] Accident data collection

[0250] 1. When an accident occurs, the user enters a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The accident data includes detailed information such as the date and time of the accident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery.

[0251] 2. The terminal checks the entered accident data and checks for errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[0252] 3. The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[0253] Analysis of the accident

[0254] 1. The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, which extracts causes and effects from the text data and identifies relevant keywords.

[0255] 2. Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of the accidents, thereby grouping accident data with similar causes and countermeasures and classifying the accidents.

[0256] Automatic generation of learning content and test questions

[0257] 1. The server uses the generative AI model to automatically generate learning content based on the extracted causes and countermeasures. The generated content includes text, diagrams, checklists, etc. related to the causes of accidents and countermeasures.

[0258] 2. The server automatically generates test questions based on the learning content to test comprehension, including multiple choice questions, word fill-in-the-blank questions, and question-and-answer questions, and these questions match the generated content.

[0259] Automatic sharing and notifications

[0260] 1. The server automatically distributes the generated learning content and test questions to the relevant user list via the company's internal messaging system or email.

[0261] 2. The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[0262] Use of emotion engine

[0263] 1. The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing. For example, changes in facial expressions when viewing learning content, or voice tones when answering test questions.

[0264] 2. The server analyzes the user's emotional data recognized by the emotion engine and adjusts the difficulty and content of the learning content accordingly. For example, if the user is confused, it will provide additional explanations.

[0265] 3. The server reflects the emotional data in the evaluation of the test results, enabling a more accurate assessment of the user's comprehension level, thereby enabling a comprehensive assessment of the user's actual comprehension level and emotional state.

[0266] Study and test

[0267] 1. Users receive a notification and can view the learning content on their device. The learning content can be easily accessed through a web browser or dedicated application.

[0268] 2. After studying, the user answers test questions on the device, and the test answers are sent to the server in real time.

[0269] Test result evaluation and follow-up

[0270] 1. The server aggregates the received test results and evaluates each user's level of understanding and emotional data. The evaluation results are displayed on a dashboard and can be confirmed by an administrator.

[0271] 2. The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even when the user's understanding is insufficient.

[0272] Specific examples

[0273] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning and testing, the device uses an emotion engine to collect user emotional data, which the server analyzes and adjusts the learning content as needed. Based on the evaluation results, the server notifies the user of additional learning as needed.

[0274] This enables efficient knowledge sharing, effectively prevents accidents from recurring, and provides a learning experience that takes users' emotions into consideration.

[0275] The processing flow will be explained below.

[0276] Step 1:

[0277] When an accident occurs, users enter a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The form includes detailed information such as the date and time of the accident, the names of the affected systems and modules, specific details of the problem, and the time until recovery.

[0278] Step 2:

[0279] The terminal checks the entered accident data to see if there are any errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[0280] Step 3:

[0281] The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[0282] Step 4:

[0283] The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, which extracts causes and effects from the text data and identifies relevant keywords.

[0284] Step 5:

[0285] Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of accidents, thereby grouping accident data with similar causes and countermeasures and classifying the accidents.

[0286] Step 6:

[0287] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures, including text, diagrams, and checklists related to the causes of accidents and countermeasures.

[0288] Step 7:

[0289] The server automatically generates test questions based on the learning content, including multiple choice, word fill-in-the-blank, and question-and-answer formats, that match the generated content.

[0290] Step 8:

[0291] The server automatically distributes the generated learning content and test questions to the relevant user list via the company's internal messaging system or email.

[0292] Step 9:

[0293] The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[0294] Step 10:

[0295] The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing, such as changes in facial expressions when viewing learning content or voice tones when answering test questions.

[0296] Step 11:

[0297] The server analyzes the user's emotional data recognized by the emotion engine and adjusts the difficulty and content of the learning content accordingly. For example, if the user is confused, it will provide additional explanations.

[0298] Step 12:

[0299] Users receive notifications and can view the learning content on their devices, which can be easily accessed through a web browser or dedicated application.

[0300] Step 13:

[0301] After studying, users answer test questions on their devices, and the answers are sent to the server in real time.

[0302] Step 14:

[0303] The server aggregates the received test results and evaluates each user's level of understanding and emotional data. The evaluation results are displayed on a dashboard and can be checked by an administrator.

[0304] Step 15:

[0305] The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even if the user's understanding is insufficient.

[0306] Examples:

[0307] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning and testing, the device uses an emotion engine to collect user emotional data, which the server analyzes and adjusts the learning content as needed. Based on the evaluation results, the server notifies the user of additional learning as needed.

[0308] Example 2

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

[0310] Large development organizations are seeking systems that can prevent accidents and share knowledge quickly and efficiently. Furthermore, existing learning systems do not take users' emotions into account, making effective learning difficult and preventing improvements in understanding. The present invention aims to solve these problems and provide an effective learning system that takes users' emotions into account.

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

[0312] In this invention, the server includes means for collecting accident data, means for verifying the collected accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for analyzing the collected accident data using a natural language processing model, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating learning content using a generative AI model, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the generated learning content and test questions to relevant users, means for recognizing user emotions using an emotion engine, means for adjusting the learning content based on the recognized emotion data, means for users to study and test, and means for collecting and evaluating user test results and emotion data. This enables the prevention of accident recurrence, the rapid sharing of knowledge, and effective learning that takes user emotions into consideration.

[0313] "Accident data" refers to detailed information about an accident that has occurred, such as an overview, cause, impact, and countermeasures, that is entered into the system by the user.

[0314] "Means of collection" refers to the function of providing a dedicated form or interface for users to input accident data and importing that data into the system.

[0315] "Means of verification" refers to functions that check whether collected accident data has been entered correctly, whether required fields have been filled in, and whether the data format has been confirmed.

[0316] "Means of analysis" refers to the function of analyzing collected accident data using natural language processing (NLP) models, etc., to extract the causes of accidents and countermeasures.

[0317] A "natural language processing model" refers to algorithms and technologies for analyzing text data, understanding its meaning, and extracting important information.

[0318] "Means of extraction" refers to the function of deriving the cause of an accident and countermeasures from the analyzed data.

[0319] A "generative AI model" refers to artificial intelligence technology that automatically generates learning content and test questions based on input data.

[0320] "Learning content" refers to educational materials such as texts, charts, and checklists that contain information about the causes of accidents and countermeasures.

[0321] "Means for automatic generation" refers to the function of automatically creating learning content and test questions based on collected and analyzed data.

[0322] "Test questions" are a set of questions designed to test a user's level of understanding based on the learning content, and include multiple choice questions and fill-in-the-blank questions.

[0323] "Means for automatic distribution" refers to the function of automatically sending generated learning content and test questions to relevant users.

[0324] An "emotion engine" refers to the technology and algorithms used to analyze a user's facial expressions and voice to recognize their emotions.

[0325] "Emotional Data" refers to data regarding a user's emotional state collected using an emotion engine.

[0326] "Means of adjustment" refers to the function of appropriately changing the learning content, difficulty of test questions, etc. based on collected emotional data.

[0327] "User" means any individual or member of an organization who uses the System.

[0328] "Means of evaluation" refers to the function of compiling users' test results and emotional data to comprehensively assess their level of understanding.

[0329] The "system" refers to a comprehensive set of technologies and devices that combine the aforementioned measures to prevent accidents from recurring, share knowledge, and provide an effective learning experience.

[0330] This invention is a system that improves the efficiency of accident prevention and knowledge sharing in large development organizations, and further improves the effectiveness of the learning process by combining it with user emotion recognition. This system is mainly composed of a server, terminals, and users.

[0331] Accident data collection

[0332] The user enters details of the accident into a dedicated form in the system. The data to be entered includes the date and time of the accident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery. The terminal verifies the entered data, checking whether required fields have been filled in and whether the data format is correct. If there are any errors, an error message is displayed to the user. The server stores the accident data in a database once it has been confirmed to be in the correct format.

[0333] Analysis of the accident

[0334] The server retrieves accident data from the database and analyzes the text data using a natural language processing (NLP) model. The model extracts causes and effects from accident reports and identifies relevant keywords. It then uses a clustering algorithm to classify similar accidents and extract causes and countermeasures.

[0335] Automatic generation of learning content and test questions

[0336] The server uses a generative AI model to automatically generate learning content from the analysis results. The generated content includes text, diagrams, checklists, and other information related to the causes of accidents and countermeasures. Furthermore, test questions to test comprehension are automatically created based on the learning content. Test questions include multiple choice questions, word fill-in-the-blank questions, and question-and-answer format questions.

[0337] Automatic sharing and notifications

[0338] The server automatically distributes the generated learning content and test questions to relevant users via an internal messaging system or email. The device then notifies the user of the distributed content and test questions.

[0339] Use of emotion engine

[0340] The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing. For example, it monitors changes in facial expressions and tone of voice. The server analyzes the collected emotion data and adjusts the difficulty and content of the learning content accordingly. It can also provide additional explanations to confused users.

[0341] Study and test

[0342] Users receive notifications and can view the learning content on their devices via a web browser or dedicated application. After studying, users answer test questions, and their answers are sent to the server in real time.

[0343] Test result evaluation and follow-up

[0344] The server aggregates the test results and collected emotional data to evaluate each user's level of understanding. The evaluation results are displayed on a dashboard for administrators to review. If necessary, instructions for additional follow-up learning or retesting are automatically sent.

[0345] Specific examples

[0346] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server then uses a natural language processing model to identify "insufficient reviews" and recommends "strengthening reviews" as a countermeasure. The server then uses a generative AI model to automatically generate learning content on "best practices for code reviews" and create test questions on "risks caused by insufficient reviews." The content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning, the device uses an emotion engine to collect user emotion data, and the server sends additional learning instructions based on the analysis results.

[0347] Prompt Sentence Examples

[0348] We recently had an incident in our internal system. Please input the details of this incident, analyze it, and generate appropriate learning content and test questions.

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

[0350] Step 1:

[0351] The user enters incident data into a dedicated form in the system. The input data includes the date and time of the incident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery. This data provides basic information about the incident. When the input data is sent to the form, the terminal receives and temporarily stores the data.

[0352] Step 2:

[0353] The terminal verifies the accident data entered by the user. Specifically, it checks whether all required fields are filled in and whether the date and time format is correct. For example, it checks whether the date and time of the accident was entered in the format "mm / dd / yyyy hh:mm." If an error is detected during this verification step, the terminal displays an error message to the user and prompts them to re-enter the data. If the input is correct, the data passes the format check and is sent to the server.

[0354] Step 3:

[0355] The server receives the accident data that has been confirmed to be in the correct format and stores it in a database. The database stores information such as the identifier of each accident report, the date and time of the incident, the person who made the report, and the department in charge. The input to this step is the accident data sent from the terminal, and the output is the accident data stored in the database.

[0356] Step 4:

[0357] The server extracts accident data from the database and sends it to a natural language processing (NLP) model to analyze the accident details. The input is the acquired text data, and the output is a list of keywords indicating the extracted causes and effects. For example, the keyword "database connection error" is extracted.

[0358] Step 5:

[0359] The server uses a clustering algorithm to classify similar accidents based on the keywords extracted from the NLP model. The input is a list of keywords generated by the NLP model, and the output is a set of clusters of similar accidents. This allows accidents caused by the same reasons to be grouped together.

[0360] Step 6:

[0361] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures. The input is the clustered accidents, their causes, and countermeasures, and the output is learning content (text, diagrams, checklists, etc.). For example, content containing detailed explanations on "countermeasures for database connection errors" is generated.

[0362] Step 7:

[0363] The server also automatically generates test questions to test comprehension based on the generated learning content. The input is the generated learning content, and the output is multiple-choice questions, word fill-in-the-blank questions, and question-and-answer style test questions. As a specific example, a multiple-choice question such as "What is the cause of the database connection error?" is created.

[0364] Step 8:

[0365] The server distributes the generated learning content and test questions to the relevant users. Notifications are sent via the company's internal messaging system or email. The input is the learning content and test questions, and the output is the notification message. The terminal receives this and displays a pop-up or notification to the user.

[0366] Step 9:

[0367] The device uses an emotion engine to recognize the user's facial expressions and voice during training and testing. The input is video and audio data captured by a camera and microphone, and the output is recognized emotion data. For example, if the user is confused, that emotion data is collected.

[0368] Step 10:

[0369] The server analyzes the emotional data obtained from the emotion engine and automatically adjusts the difficulty level of the learning content and additional explanations. The input is emotional data, and the output is a specific action such as "display a link to additional explanations."

[0370] Step 11:

[0371] The user actually views the learning content that has been notified to them. By accessing it from their device, they can proceed with their learning through a web browser or dedicated application. The input is a request to access the learning content, and the output is the displayed learning content.

[0372] Step 12:

[0373] After studying, users answer test questions on their devices. The answers are sent to the server in real time, and the test is evaluated. The input is the user's answer data, and the output is the test results.

[0374] Step 13:

[0375] The server integrates the received test results and emotional data to evaluate the overall level of understanding. The results are displayed on a dashboard for administrator confirmation. The input is the test results and emotional data, and the output is an evaluation report and dashboard display.

[0376] Step 14:

[0377] The server notifies the user of additional follow-up study or retesting as necessary. The input is the evaluation result, and the output is a notification of follow-up study or retesting. For example, a notification such as "Please conduct additional study" is sent to a user who did not understand the material sufficiently.

[0378] Prompt Sentence Examples

[0379] We recently had an incident in our internal system. Please input the details of this incident, analyze it, and generate appropriate learning content and test questions.

[0380] (Application example 2)

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

[0382] Systems for preventing accidents and efficiently sharing knowledge in factories require the collection of accident data, analysis of causes, generation and distribution of effective learning content, recognition of user emotions, and real-time adjustment of learning content. Accidents have a significant impact on production efficiency, particularly in factory environments, so it is essential to quickly and accurately identify the causes of accidents and share related knowledge. Furthermore, to increase employees' motivation and understanding, it is necessary to introduce emotion recognition and provide individually optimized learning experiences.

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

[0384] In this invention, the server includes a means for collecting accident data, a means for analyzing the accident data to extract causes of accidents and countermeasures, and a means for automatically generating learning content based on the extracted causes and countermeasures. This enables rapid and accurate identification of accident causes. The server also includes a means for automatically generating test questions to test comprehension based on the learning content, a means for automatically distributing the automatically generated learning content and test questions to relevant users, a means for users to study and test, a means for collecting and evaluating users' test results, a means for identifying users' emotions using an emotion engine and adjusting the content of the learning content and tests based on the emotions, and a means for providing robots and sensors for collecting accident data in a factory environment, analyzing the data collected by the robots, and generating and distributing learning content. This provides an optimized learning experience for each employee, thereby preventing accidents and improving the efficiency of knowledge sharing throughout the factory.

[0385] "Incident Data" means information relating to an accident that occurred in a factory or other environment, including the date and time of the accident, its cause, the extent of its impact, and remediation measures.

[0386] "Analysis" refers to the analytical methods used to identify causes and countermeasures from collected accident data. This analysis uses technologies such as natural language processing and image recognition.

[0387] "Learning content" refers to educational materials generated from accident data, including text explanations, diagrams, and checklists.

[0388] "Test questions" are questions that test a user's understanding of the learning content. These questions include multiple choice questions and fill-in-the-blank questions.

[0389] An "emotion engine" is software that identifies emotions from a user's facial expressions and voice. This engine is used to improve the effectiveness of learning content and tests.

[0390] "Robots" are automated machinery used to collect and analyze incident data in factory environments, including through video capture and sensor data collection.

[0391] A "sensor" is a device that detects the physical conditions of the environment (temperature, pressure, humidity, etc.) and collects that data. It is used to identify accidents and analyze their causes.

[0392] A "natural language processing model" is an algorithm for analyzing text data and extracting specific information (such as causes and countermeasures). This model uses AI technology to understand the text.

[0393] A "generative AI model" is an artificial intelligence technology that automatically generates learning content and test questions based on accident data. This model generates content based on input data.

[0394] "Automated Delivery" means the automatic transmission of generated learning content and test questions to relevant users via internal messaging systems and / or email.

[0395] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in factories. The system collects and analyzes accident data, and automatically generates learning content and test questions based on that data and delivers them to users. It also has the ability to identify user emotions using an emotion engine and adjust the content of the learning process accordingly.

[0396] Accident data collection

[0397] When an accident occurs in a factory, the user provides details to the system using a dedicated form or voice input. At this time, the robot uses environmental sensors and CCTV cameras to collect video and physical data from the accident site. This data is collected and verified in real time by a mini server, such as the NVIDIA Jetson series.

[0398] Analysis of the accident

[0399] The server stores the accident data in a database and analyzes the text data using a natural language processing model (e.g., OpenAI GPT-4). This identifies the cause of the accident and countermeasures, and extracts highly relevant keywords. Furthermore, image recognition algorithms such as the YOLO series are used to detect anomalies in the video data.

[0400] Automatic generation of learning content and test questions

[0401] Based on the analysis results, the server uses a generative AI model (e.g., GPT-4) to automatically generate learning content. This content includes detailed explanations of the causes of accidents and countermeasures, diagrams, checklists, etc. Test questions are also automatically generated, including multiple-choice and fill-in-the-blank questions.

[0402] Automatic sharing and notifications

[0403] The server automatically distributes the generated learning content and test questions to relevant users via the company's internal messaging system, email, kiosk terminals in the factory, and smartphone apps.

[0404] Use of emotion engine

[0405] The server uses an emotion engine (e.g., Affectiva) to identify emotions from the user's facial expressions and voice during learning and testing, allowing it to adjust the difficulty and content of the learning content in real time, and provide additional explanations if the user is confused, for example.

[0406] Study and test

[0407] Users can view the delivered learning content on their devices, study, and then answer test questions, with the test results sent to the server in real time.

[0408] Test result evaluation and follow-up

[0409] The server aggregates test results and emotion data to evaluate the user's level of understanding. Based on the evaluation results, instructions for additional study or retesting are automatically sent as needed. This allows for quick response even if the user's understanding is insufficient.

[0410] Specific examples

[0411] For example, if an accident occurs in a factory due to a machine malfunction, the user enters the details of the accident into the system (e.g., "The production line stopped due to a machine malfunction. The cause was a sensor failure. The response was to replace the sensor and perform regular maintenance"). The server analyzes this and identifies "machine malfunction" as the cause and "sensor replacement and regular maintenance" as the response.

[0412] The server then uses the generative AI model to automatically generate learning content and test questions related to "procedures to prevent operational errors" and "regular maintenance techniques." These content and test questions are then distributed to the relevant employee's devices, where the user studies and takes the test. During this process, the emotion engine recognizes the user's emotions and adjusts the learning content as necessary.

[0413] Examples of prompt statements

[0414] "Accident report: A machine malfunction caused the production line to stop. The cause was a sensor failure. The solution was to replace the sensor and perform regular maintenance."

[0415] "Based on the above situation, please generate learning content and test questions related to safety management."

[0416] This invention automates the safety management and knowledge sharing process within factories, providing employees with quick and effective accident prevention measures. Individual adjustments using an emotion engine can also improve learning effectiveness.

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

[0418] Step 1: Collect accident data

[0419] When an accident occurs, the user enters details of the accident into the system using a dedicated form or voice input. The input includes the date and time of the accident, the location, a detailed description of the situation, the cause, and initial response measures. The robot also uses environmental sensors and CCTV cameras to collect video and physical data from the accident site. This allows accident data to be collected in real time.

[0420] Input: Accident details (date, time, location, explanation of the situation, cause, initial response measures), environmental sensor data, CCTV footage

[0421] Output: Accident dataset

[0422] Step 2: Review and save your data

[0423] The terminal checks the accident data collected from the user and robot, verifying that required fields have been filled in and that the data format is correct. If there are any errors, it notifies the user with a message and prompts them to correct the errors. If there are no errors, it sends the data to the server, which then stores the received data in a database.

[0424] Input: Accident dataset

[0425] Output: Confirmed accident data, error message (if necessary)

[0426] Step 3: Analysis of the accident

[0427] The server retrieves the stored accident data from the database and analyzes the text data using a natural language processing model (e.g., OpenAI GPT-4). The model extracts causes and effects from the text data and identifies relevant keywords. It also analyzes video data using image recognition algorithms such as the YOLO series to detect anomalies.

[0428] Input: Confirmed accident data

[0429] Output: Accident cause analysis results, related keywords, anomaly detection results

[0430] Step 4: Automatic generation of learning content and test questions

[0431] Based on the analysis results, the server automatically generates learning content and test questions using a generative AI model (e.g., GPT-4). The learning content includes detailed explanations of the causes of accidents and countermeasures, as well as diagrams and checklists, while the test questions include multiple-choice and fill-in-the-blank questions.

[0432] Input: Accident cause analysis results, related keywords, anomaly detection results

[0433] Output: Learning content, test questions

[0434] Step 5: Automated Delivery

[0435] The server automatically distributes the generated learning content and test questions based on the associated user list via the company's internal messaging system, email, factory kiosks, and smartphone apps.

[0436] Input: learning content, test questions

[0437] Output: Delivery notification (internal messaging, email, app notification)

[0438] Step 6: Training and testing

[0439] The user receives a notification of delivery, browses the learning content on their device, studies, and then answers the test questions. The test answers are sent to the server in real time.

[0440] Input: Delivery notification

[0441] Output: Test answer

[0442] Step 7: Collect emotion data

[0443] During training and testing, the device uses an emotion engine (e.g., Affectiva) to collect emotion data from the user's facial expressions and voice, which is then transmitted to the server in real time.

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

[0445] Output: Emotion data

[0446] Step 8: Evaluate test results and sentiment data

[0447] The server aggregates test answers and emotional data to evaluate the user's level of understanding and emotional state, and based on the evaluation results, it readjusts the learning content or provides instructions for additional learning.

[0448] Input: Test answers, emotion data

[0449] Output: Comprehension assessment results, readjustment instructions, additional study instructions

[0450] Step 9: Follow up

[0451] Based on the evaluation results, the server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action to be taken even if the user's understanding is insufficient.

[0452] Input: Comprehension assessment results, readjustment instructions, additional study instructions

[0453] Output: Follow-up notification (re-learning, re-test instructions)

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

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

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

[0457] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0470] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in large development organizations. Below, we will explain the program processing of this system in natural language, and provide concrete examples.

[0471] System Overview

[0472] This system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users, thereby quickly sharing knowledge for accident prevention. The entire system is mainly composed of a server, terminals, and users.

[0473] Accident data collection

[0474] 1. When an accident occurs, the user enters the accident data into a form for entering details of the accident. The accident data includes the date and time of the accident, the extent of the impact, the cause, specific details of the problem, and countermeasures.

[0475] 2. The terminal checks the format of the entered accident data and performs error checking to notify of input errors if necessary.

[0476] 3. The server stores the correctly formatted accident data in a database for later analysis.

[0477] Analysis of the accident

[0478] 1. The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, thereby extracting the causes of the accident and countermeasures.

[0479] 2. The server uses a clustering algorithm to group accident data with similar causes and countermeasures and organize the analysis results.

[0480] Automatic generation of learning content and test questions

[0481] 1. The server uses a generative AI model to automatically generate learning content from the analysis results, including text, diagrams, and checklists, with detailed explanations of specific examples and countermeasures.

[0482] 2. The server then automatically generates test questions based on the generated learning content to test comprehension, including multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[0483] Automatic sharing and notifications

[0484] 1. The server automatically distributes the generated learning content and test questions to a list of relevant users via an internal messaging system or email.

[0485] 2. The device sends a notification to the user so that they can access the delivered learning content and test questions.

[0486] Study and test

[0487] 1. Users receive a notification and can view the learning content on their device. The learning content can be easily accessed through a web browser or dedicated application.

[0488] 2. After studying, the user answers test questions on their device. The test results are sent to the server in real time.

[0489] Test result evaluation and follow-up

[0490] 1. The server aggregates the received test results and evaluates each user's level of understanding. The results are displayed on a dashboard so that administrators can check their progress.

[0491] 2. The server will then provide instructions for follow-up study as needed, and may automatically notify students of retests or additional assignments.

[0492] Specific examples

[0493] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. Next, the server uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and takes the test, and their level of understanding is evaluated. Based on the results of the evaluation, the server notifies them of additional learning as necessary.

[0494] This will enable efficient sharing of knowledge and effectively prevent accidents from occurring again.

[0495] The processing flow will be explained below.

[0496] Step 1:

[0497] When an accident occurs, users enter a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The form includes detailed information such as the date and time of the accident, the names of the affected systems and modules, specific details of the problem, and the time until recovery.

[0498] Step 2:

[0499] The terminal checks the entered accident data to see if there are any errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[0500] Step 3:

[0501] The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[0502] Step 4:

[0503] The server runs a natural language processing (NLP) model to analyze the stored accident data, extracting causes and effects from the text data and identifying relevant keywords.

[0504] Step 5:

[0505] Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of accidents, which allows accidents with similar causes and countermeasures to be grouped together and classified.

[0506] Step 6:

[0507] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures, including text, diagrams, and checklists related to the causes of accidents and countermeasures.

[0508] Step 7:

[0509] The server automatically generates test questions based on the learning content, including multiple choice, word fill-in-the-blank, and question-and-answer formats, that match the generated content.

[0510] Step 8:

[0511] The server automatically distributes the generated learning content and test questions to relevant users, including departments affected by the incident and members of related teams.

[0512] Step 9:

[0513] The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[0514] Step 10:

[0515] Users receive notifications and can view the learning content through a web interface or dedicated application on their device. The learning content is easily accessible and intuitive to use.

[0516] Step 11:

[0517] After studying, users answer test questions on their devices, and the answers are sent to the server in real time.

[0518] Step 12:

[0519] The server aggregates the received test results and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard and can be checked by an administrator.

[0520] Step 13:

[0521] The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even if the user's understanding is insufficient.

[0522] Example 1

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

[0524] When an accident occurs in a large development organization, it is necessary to quickly and effectively share the cause and countermeasures. However, with conventional methods, collecting and analyzing accident data takes time, which often delays the sharing of knowledge. In addition, manually creating learning content and test questions requires a great deal of effort, resulting in a decrease in the effectiveness of education. A system is needed to solve these issues and efficiently prevent accidents and share knowledge.

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

[0526] In this invention, the server includes means for collecting accident data, means for checking the format of the collected accident data and notifying of input errors, means for analyzing the accident data to extract causes of the accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to relevant users, means for users to study and test, means for collecting and evaluating user test results, and means for instructing additional follow-up study based on the evaluation results. This enables the entire process from collecting accident data to automatically generating, distributing, and evaluating learning content and test questions to be carried out efficiently.

[0527] "Accident data" is data collected when an accident occurs, including information such as the date and time of the accident, the extent of the impact, the cause, the specific details of the problem, and countermeasures.

[0528] The "means of collection" refers to the means by which accident data is input by users and then imported into the system.

[0529] The "means for checking the format and notifying of input errors" refers to a means for checking whether the values ​​in each field of the collected accident data are in the appropriate format, and for prompting the user to re-enter the data if there is an error.

[0530] "Means of analyzing and extracting the causes of accidents and countermeasures" refers to analyzing collected accident data using natural language processing models, etc., and extracting the causes of accidents and countermeasures.

[0531] "Means for automatically generating learning content" refers to a means for automatically generating content (text, illustrations, checklists, etc.) for users to study based on the analysis results using a generative AI model.

[0532] "Means for automatically generating test questions to test comprehension" refers to a means for automatically generating test questions (multiple choice questions, fill-in-the-blank questions, question-and-answer questions, etc.) to evaluate a user's level of comprehension based on the generated learning content.

[0533] The "means for automatically distributing automatically generated learning content and test questions to relevant users" refers to a means for automatically distributing the generated learning content and test questions to relevant users.

[0534] "Means for learning and testing" refers to the means by which a user can view learning content and answer test questions.

[0535] The "means for collecting and evaluating test results" refers to a means for aggregating test results sent by users and evaluating the level of understanding of each user.

[0536] The "means for instructing additional follow-up study" refers to a means for instructing the user on necessary additional study based on the evaluation of the test results, and for notifying the user of retests or additional assignments.

[0537] This invention is a system for efficiently preventing accidents and sharing knowledge in large development organizations. This system collects and analyzes accident data, automatically generates learning content and test questions based on the data, and distributes them to users, thereby quickly sharing knowledge for preventing accidents. The entire system is mainly composed of a server, terminals, and users.

[0538] An embodiment of the system will now be described in detail.

[0539] First, when an accident occurs, the user accesses a dedicated form and enters the accident data (date and time of occurrence, extent of impact, cause, specific details of the failure, countermeasures, etc.). For example, this can be done using a web browser. After the user has completed the input, they press the send button, which sends the data to the server.

[0540] The terminal receives this data and performs a format check. For example, it checks whether the date and time information is in the "YYYY-MM-DD" format. If there is an error in the input, it displays an error message to the user and prompts them to re-enter the information.

[0541] The server stores the correct formatted accident data sent from the device in a database (for example, MySQL) for later analysis.

[0542] The server retrieves accident data from the database and analyzes the text data using a natural language processing (NLP) model (e.g., BERT), thereby extracting the causes of the accident and countermeasures.

[0543] The server then uses a clustering algorithm (e.g., K-means) to group incident data with the same causes and countermeasures, making it easier to identify similar patterns.

[0544] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content from the analysis results. For example, it generates learning materials such as best practices and checklists for the extracted "lack of review." The server then automatically generates test questions (multiple choice questions, fill-in-the-blank questions, question-and-answer questions, etc.) to test comprehension based on the generated learning content.

[0545] The server automatically distributes these learning contents and test questions to relevant users, for example, via an internal messaging system (e.g., Slack) or email.

[0546] The device notifies the user when new learning content and test questions have been distributed. The user receives the notification and accesses the learning content from their device (PC or smartphone). The learning content can be easily accessed through a web browser or dedicated application.

[0547] Users study the content and answer test questions. The test results are sent in real time to the server, which then aggregates them and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard, allowing administrators to monitor progress.

[0548] Based on the evaluation results, the server automatically recommends additional follow-up learning, and will also notify students of retests or additional assignments as necessary.

[0549] As a specific example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident. The device performs a format check and, if no errors are found, sends the data to the server. The server uses a natural language processing model to identify "insufficient reviews" as the cause and "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the devices of the relevant developers, and the users study and take the test, with their level of understanding being evaluated by the server. Depending on the evaluation results, the server notifies them of additional learning as necessary.

[0550] An example of a prompt is, "Please explain the cause and solution of a system outage that occurred in a certain development team. Also, please generate appropriate learning content and test questions based on that." This system will enable efficient knowledge sharing and the prevention of accident recurrence.

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

[0552] Step 1:

[0553] When an accident occurs, the user accesses a dedicated form and enters the accident data (date and time of occurrence, extent of impact, cause, specific details of the problem, countermeasures, etc.). After completing the input, the user clicks the send button.

[0554] Input: Accident data (occurrence date and time, extent of impact, cause, specific details of the failure, countermeasures)

[0555] Output: Accident data entered into the form

[0556] Step 2:

[0557] The terminal receives the transmitted accident data and performs format checks, for example, checking that the date field is in "YYYY-MM-DD" format, and if there is an error, it displays an error message to the user and asks them to re-enter the data.

[0558] Input: Accident data submitted via the form

[0559] Output: Correctly formatted incident data or an error message

[0560] Step 3:

[0561] The server stores the correct formatted accident data sent from the device in a database (e.g., MySQL).

[0562] Input: Accident data that passes format check

[0563] Output: Accident data stored in a database

[0564] Step 4:

[0565] The server retrieves accident data from the database, analyzes the text data using a natural language processing (NLP) model (e.g., BERT), and extracts the causes of the accident and countermeasures.

[0566] Input: Accident data retrieved from the database

[0567] Output: Extracted causes of accidents and countermeasures

[0568] Step 5:

[0569] The server uses a clustering algorithm (e.g., K-means) to group similar data based on the analyzed causes and countermeasures of the accident.

[0570] Input: Extracted cause and countermeasure data

[0571] Output: Clustered accident data

[0572] Step 6:

[0573] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content from the clustering results, such as best practices for review gaps and checklists to prevent similar incidents from occurring.

[0574] Input: Clustering results

[0575] Output: Auto-generated learning content

[0576] Step 7:

[0577] The server automatically generates test questions to assess comprehension based on the generated learning content, including multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[0578] Input: Learning content

[0579] Output: Auto-generated test questions

[0580] Step 8:

[0581] The server automatically distributes the generated learning content and test questions to relevant users, for example, via an internal messaging system (e.g., Slack) or email.

[0582] Input: Learning content and test questions

[0583] Output: Delivery notification to user

[0584] Step 9:

[0585] The device will notify the user when new learning content and test questions are available via pop-ups, push notifications, emails, etc.

[0586] Input: Delivery notification from the server

[0587] Output: A message to inform the user

[0588] Step 10:

[0589] Users receive a notification and can access the learning content from their device (PC or smartphone) via a web browser or dedicated application.

[0590] Input: Delivered learning content

[0591] Output: User learning activity

[0592] Step 11:

[0593] After studying, users answer test questions using their devices, and the test results are sent to the server in real time.

[0594] Input: Answer to test question

[0595] Output: Test results sent in real time

[0596] Step 12:

[0597] The server aggregates the received test results and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard so that administrators can check their progress.

[0598] Input: Test result data

[0599] Output: Aggregated evaluation results and dashboard display

[0600] Step 13:

[0601] Based on the evaluation results, the server automatically recommends additional follow-up learning as needed, and also notifies students of retests and additional assignments.

[0602] Input: Aggregated evaluation results

[0603] Output: Notifications for follow-up study and retesting

[0604] (Application example 1)

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

[0606] Accidents in factories threaten the safety of workers and reduce productivity. Conventional systems tend to be slow to share knowledge to prevent accidents, and preventive measures are not quickly implemented. For this reason, there is a need for a system that can quickly and efficiently collect and analyze accident data, automatically generate appropriate learning content and test questions based on that data, and quickly share them with workers and robots.

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

[0608] In this invention, the server includes means for collecting accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to related workers and robots, means for workers to study and test, and means for collecting and evaluating test results. This allows knowledge on accident prevention to be shared quickly and efficiently, making it possible to prevent accidents from recurring at factory sites.

[0609] "Accident data" refers to detailed information about accidents that occur within a factory, including the date and time of the accident, the extent of the impact, the cause, the specific details of the problem, and countermeasures.

[0610] A "natural language processing model" refers to algorithms and techniques that allow computers to understand, analyze, and generate human language, providing a means of extracting meaning and context from text.

[0611] A "generative AI model" is an algorithm that uses machine learning to automatically generate new content and data, generating text, images, audio, etc. based on given input.

[0612] "Learning content" refers to learning materials for acquiring specific knowledge or skills, and includes text, illustrations, checklists, etc.

[0613] "Test questions" are questions or tasks used to assess a user's understanding of the learning content, and may include multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[0614] A "robot" is a mechanical device that automatically performs specific tasks or operations in a factory, helping to prevent accidents and share knowledge.

[0615] The "Factory Robot Support System" is an integrated system for collecting and analyzing accident data, generating and distributing learning content, generating test questions, and providing these to workers and robots.

[0616] As an embodiment of the present invention, the following factory robot support system is provided. The entire system is mainly composed of a server, terminals, and users (workers and robots). How each component of the system interacts and functions will be explained below.

[0617] System Overview

[0618] This factory robot support system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users and robots, thereby quickly sharing knowledge to prevent accidents.

[0619] Hardware and Software

[0620] Hardware

[0621] Factory robot: A device with an interface that allows workers to easily input accident data and share knowledge about accident prevention.

[0622] Server: Provides infrastructure for database management, natural language processing analysis, and generative AI model operation.

[0623] software

[0624] Natural language processing (NLP) engine: Used to analyze text data, and specific technologies include models such as BERT and GPT-3.

[0625] Clustering algorithms: Used to group accident data with similar causes and countermeasures, specific techniques include k-means.

[0626] Generative AI models: Used to automatically generate learning content and test questions; specific technologies include OpenAI's GPT-3.

[0627] Program processing explanation

[0628] 1. Entering accident data and checking for errors

[0629] When an accident occurs, the user inputs details of the accident into a terminal built into the factory robot, which then checks the input data for incomplete data or input errors.

[0630] 2. Accident data storage

[0631] Correctly formatted accident data is sent to a server and stored in a database for later analysis.

[0632] 3. Analysis of the accident

[0633] The server retrieves the accident data from the database, performs text analysis using natural language processing techniques (e.g., BERT or GPT-3), and then groups the accident data using a clustering algorithm (e.g., k-means).

[0634] 4. Automatic generation of learning content and test questions

[0635] Generative AI models (e.g., GPT-3) are used to generate learning content from the analysis results, including text, diagrams, checklists, etc. Test questions are also automatically generated to test comprehension.

[0636] 5. Delivery and Notification

[0637] The generated learning content and test questions are automatically distributed by the server to the relevant workers and robots via the factory messaging system or email, and notifications are sent by the terminals.

[0638] 6. Implementation of learning

[0639] The worker receives a notification and views the learning content on their device. After studying, they take a test, and the test results are sent to the server in real time.

[0640] 7. Evaluation and follow-up of test results

[0641] The server aggregates the received test results and evaluates each worker's level of understanding. The results are displayed on a dashboard, allowing managers to check progress and, if necessary, instruct additional follow-up learning.

[0642] Specific examples

[0643] For example, if a collision occurs while operating a forklift in a factory, the worker uses the robot's interface to input details of the accident. The server analyzes this data, identifies "misoperation of the forklift" as the cause, and extracts "improvement of operating techniques" as the countermeasure. Next, it uses a generative AI model to generate learning content on "safe forklift operation methods" and test questions on "risks caused by operating errors." These content and test questions are then distributed to the relevant workers and robots.

[0644] Example prompt for a generative AI model:

[0645] "Please create learning content that instructs students on how to improve their driving techniques regarding collision accidents that occurred due to forklift driving errors, and create test questions to measure their understanding."

[0646] This will enable accident prevention knowledge to be shared effectively within the factory, preventing recurrence.

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

[0648] Step 1: Enter accident data and check for errors

[0649] The user inputs details of the accident into a terminal built into the factory robot. The terminal receives the input accident data (date and time of occurrence, extent of impact, cause, specific details of the problem, and countermeasures) and checks for incomplete data or input errors. For example, if the date and time are inaccurate, a warning is displayed, prompting correction.

[0650] Input: Accident details

[0651] Output: Well-formatted incident data or error messages

[0652] Step 2: Save the incident data

[0653] Accident data in the correct format is sent from the device to the server, which then stores the received data in a database for later analysis.

[0654] Input: Correctly formatted accident data

[0655] Output: Accident data stored in a database

[0656] Step 3: Analysis of the accident

[0657] The server retrieves accident data from the database, performs text analysis using natural language processing techniques (e.g., BERT or GPT-3) to extract accident causes and countermeasures, and then uses a clustering algorithm (e.g., k-means) to group accident data with similar causes and countermeasures.

[0658] Input: Accident data retrieved from the database

[0659] Output: Analysis results (causes of accidents and countermeasures), grouped accident data

[0660] Step 4: Automatic generation of learning content and test questions

[0661] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content based on the causes and countermeasures of accidents. This content includes text, diagrams, checklists, etc. At the same time, test questions are automatically generated to test comprehension.

[0662] Input: Analysis results (cause of accident and countermeasures)

[0663] Output: Auto-generated learning content, test questions

[0664] Step 5: Delivery and Notification

[0665] The server automatically distributes the generated learning content and test questions to the relevant workers and robots via the factory's messaging system or email, and the terminals send notifications. Specifically, each worker receives a notification message containing a link to the content.

[0666] Input: learning content, test questions

[0667] Output: Auto-distributed content and notification messages

[0668] Step 6: Learning

[0669] The user receives a notification and views the learning content on their device. After viewing the learning content, the worker answers the test questions on their device. The test results are sent to the server in real time.

[0670] Input: learning content, test questions

[0671] Output: Answered test results (sent in real time)

[0672] Step 7: Evaluate and follow up on test results

[0673] The server aggregates the received test results and evaluates each user's level of understanding. The results are displayed on a dashboard so administrators can check progress and automatically recommend additional follow-up learning if necessary.

[0674] Input: Test result

[0675] Output: Assessment results, dashboard display, and instructions for further follow-up

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

[0677] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in large development organizations, and by combining it with user emotion recognition, it improves the effectiveness of the learning process. Below, we will explain the program processing of this system in natural language, and provide concrete examples.

[0678] System Overview

[0679] This system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users, quickly sharing knowledge for accident prevention. It also uses an emotion engine to recognize user emotions and improve the effectiveness of the learning content and tests. The entire system is primarily composed of a server, terminals, and users.

[0680] Accident data collection

[0681] 1. When an accident occurs, the user enters a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The accident data includes detailed information such as the date and time of the accident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery.

[0682] 2. The terminal checks the entered accident data and checks for errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[0683] 3. The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[0684] Analysis of the accident

[0685] 1. The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, which extracts causes and effects from the text data and identifies relevant keywords.

[0686] 2. Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of the accidents, thereby grouping accident data with similar causes and countermeasures and classifying the accidents.

[0687] Automatic generation of learning content and test questions

[0688] 1. The server uses the generative AI model to automatically generate learning content based on the extracted causes and countermeasures. The generated content includes text, diagrams, checklists, etc. related to the causes of accidents and countermeasures.

[0689] 2. The server automatically generates test questions based on the learning content to test comprehension, including multiple choice questions, word fill-in-the-blank questions, and question-and-answer questions, and these questions match the generated content.

[0690] Automatic sharing and notifications

[0691] 1. The server automatically distributes the generated learning content and test questions to the relevant user list via the company's internal messaging system or email.

[0692] 2. The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[0693] Use of emotion engine

[0694] 1. The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing. For example, changes in facial expressions when viewing learning content, or voice tones when answering test questions.

[0695] 2. The server analyzes the user's emotional data recognized by the emotion engine and adjusts the difficulty and content of the learning content accordingly. For example, if the user is confused, it will provide additional explanations.

[0696] 3. The server reflects the emotional data in the evaluation of the test results, enabling a more accurate assessment of the user's comprehension level, thereby enabling a comprehensive assessment of the user's actual comprehension level and emotional state.

[0697] Study and test

[0698] 1. Users receive a notification and can view the learning content on their device. The learning content can be easily accessed through a web browser or dedicated application.

[0699] 2. After studying, the user answers test questions on the device, and the test answers are sent to the server in real time.

[0700] Test result evaluation and follow-up

[0701] 1. The server aggregates the received test results and evaluates each user's level of understanding and emotional data. The evaluation results are displayed on a dashboard and can be confirmed by an administrator.

[0702] 2. The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even when the user's understanding is insufficient.

[0703] Specific examples

[0704] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning and testing, the device uses an emotion engine to collect user emotional data, which the server analyzes and adjusts the learning content as needed. Based on the evaluation results, the server notifies the user of additional learning as needed.

[0705] This enables efficient knowledge sharing, effectively prevents accidents from recurring, and provides a learning experience that takes users' emotions into consideration.

[0706] The processing flow will be explained below.

[0707] Step 1:

[0708] When an accident occurs, users enter a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The form includes detailed information such as the date and time of the accident, the names of the affected systems and modules, specific details of the problem, and the time until recovery.

[0709] Step 2:

[0710] The terminal checks the entered accident data to see if there are any errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[0711] Step 3:

[0712] The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[0713] Step 4:

[0714] The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, which extracts causes and effects from the text data and identifies relevant keywords.

[0715] Step 5:

[0716] Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of accidents, thereby grouping accident data with similar causes and countermeasures and classifying the accidents.

[0717] Step 6:

[0718] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures, including text, diagrams, and checklists related to the causes of accidents and countermeasures.

[0719] Step 7:

[0720] The server automatically generates test questions based on the learning content, including multiple choice, word fill-in-the-blank, and question-and-answer formats, that match the generated content.

[0721] Step 8:

[0722] The server automatically distributes the generated learning content and test questions to the relevant user list via the company's internal messaging system or email.

[0723] Step 9:

[0724] The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[0725] Step 10:

[0726] The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing, such as changes in facial expressions when viewing learning content or voice tones when answering test questions.

[0727] Step 11:

[0728] The server analyzes the user's emotional data recognized by the emotion engine and adjusts the difficulty and content of the learning content accordingly. For example, if the user is confused, it will provide additional explanations.

[0729] Step 12:

[0730] Users receive notifications and can view the learning content on their devices, which can be easily accessed through a web browser or dedicated application.

[0731] Step 13:

[0732] After studying, users answer test questions on their devices, and the answers are sent to the server in real time.

[0733] Step 14:

[0734] The server aggregates the received test results and evaluates each user's level of understanding and emotional data. The evaluation results are displayed on a dashboard and can be checked by an administrator.

[0735] Step 15:

[0736] The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even if the user's understanding is insufficient.

[0737] Examples:

[0738] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning and testing, the device uses an emotion engine to collect user emotional data, which the server analyzes and adjusts the learning content as needed. Based on the evaluation results, the server notifies the user of additional learning as needed.

[0739] Example 2

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

[0741] Large development organizations are seeking systems that can prevent accidents and share knowledge quickly and efficiently. Furthermore, existing learning systems do not take users' emotions into account, making effective learning difficult and preventing improvements in understanding. The present invention aims to solve these problems and provide an effective learning system that takes users' emotions into account.

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

[0743] In this invention, the server includes means for collecting accident data, means for verifying the collected accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for analyzing the collected accident data using a natural language processing model, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating learning content using a generative AI model, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the generated learning content and test questions to relevant users, means for recognizing user emotions using an emotion engine, means for adjusting the learning content based on the recognized emotion data, means for users to study and test, and means for collecting and evaluating user test results and emotion data. This enables the prevention of accident recurrence, the rapid sharing of knowledge, and effective learning that takes user emotions into consideration.

[0744] "Accident data" refers to detailed information about an accident that has occurred, such as an overview, cause, impact, and countermeasures, that is entered into the system by the user.

[0745] "Means of collection" refers to the function of providing a dedicated form or interface for users to input accident data and importing that data into the system.

[0746] "Means of verification" refers to functions that check whether collected accident data has been entered correctly, whether required fields have been filled in, and whether the data format has been confirmed.

[0747] "Means of analysis" refers to the function of analyzing collected accident data using natural language processing (NLP) models, etc., to extract the causes of accidents and countermeasures.

[0748] A "natural language processing model" refers to algorithms and technologies for analyzing text data, understanding its meaning, and extracting important information.

[0749] "Means of extraction" refers to the function of deriving the cause of an accident and countermeasures from the analyzed data.

[0750] A "generative AI model" refers to artificial intelligence technology that automatically generates learning content and test questions based on input data.

[0751] "Learning content" refers to educational materials such as texts, charts, and checklists that contain information about the causes of accidents and countermeasures.

[0752] "Means for automatic generation" refers to the function of automatically creating learning content and test questions based on collected and analyzed data.

[0753] "Test questions" are a set of questions designed to test a user's level of understanding based on the learning content, and include multiple choice questions and fill-in-the-blank questions.

[0754] "Means for automatic distribution" refers to the function of automatically sending generated learning content and test questions to relevant users.

[0755] An "emotion engine" refers to the technology and algorithms used to analyze a user's facial expressions and voice to recognize their emotions.

[0756] "Emotional Data" refers to data regarding a user's emotional state collected using an emotion engine.

[0757] "Means of adjustment" refers to the function of appropriately changing the learning content, difficulty of test questions, etc. based on collected emotional data.

[0758] "User" means any individual or member of an organization who uses the System.

[0759] "Means of evaluation" refers to the function of compiling users' test results and emotional data to comprehensively assess their level of understanding.

[0760] The "system" refers to a comprehensive set of technologies and devices that combine the aforementioned measures to prevent accidents from recurring, share knowledge, and provide an effective learning experience.

[0761] This invention is a system that improves the efficiency of accident prevention and knowledge sharing in large development organizations, and further improves the effectiveness of the learning process by combining it with user emotion recognition. This system is mainly composed of a server, terminals, and users.

[0762] Accident data collection

[0763] The user enters details of the accident into a dedicated form in the system. The data to be entered includes the date and time of the accident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery. The terminal verifies the entered data, checking whether required fields have been filled in and whether the data format is correct. If there are any errors, an error message is displayed to the user. The server stores the accident data in a database once it has been confirmed to be in the correct format.

[0764] Analysis of the accident

[0765] The server retrieves accident data from the database and analyzes the text data using a natural language processing (NLP) model. The model extracts causes and effects from accident reports and identifies relevant keywords. It then uses a clustering algorithm to classify similar accidents and extract causes and countermeasures.

[0766] Automatic generation of learning content and test questions

[0767] The server uses a generative AI model to automatically generate learning content from the analysis results. The generated content includes text, diagrams, checklists, and other information related to the causes of accidents and countermeasures. Furthermore, test questions to test comprehension are automatically created based on the learning content. Test questions include multiple choice questions, word fill-in-the-blank questions, and question-and-answer format questions.

[0768] Automatic sharing and notifications

[0769] The server automatically distributes the generated learning content and test questions to relevant users via an internal messaging system or email. The device then notifies the user of the distributed content and test questions.

[0770] Use of emotion engine

[0771] The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing. For example, it monitors changes in facial expressions and tone of voice. The server analyzes the collected emotion data and adjusts the difficulty and content of the learning content accordingly. It can also provide additional explanations to confused users.

[0772] Study and test

[0773] Users receive notifications and can view the learning content on their devices via a web browser or dedicated application. After studying, users answer test questions, and their answers are sent to the server in real time.

[0774] Test result evaluation and follow-up

[0775] The server aggregates the test results and collected emotional data to evaluate each user's level of understanding. The evaluation results are displayed on a dashboard for administrators to review. If necessary, instructions for additional follow-up learning or retesting are automatically sent.

[0776] Specific examples

[0777] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server then uses a natural language processing model to identify "insufficient reviews" and recommends "strengthening reviews" as a countermeasure. The server then uses a generative AI model to automatically generate learning content on "best practices for code reviews" and create test questions on "risks caused by insufficient reviews." The content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning, the device uses an emotion engine to collect user emotion data, and the server sends additional learning instructions based on the analysis results.

[0778] Prompt Sentence Examples

[0779] We recently had an incident in our internal system. Please input the details of this incident, analyze it, and generate appropriate learning content and test questions.

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

[0781] Step 1:

[0782] The user enters incident data into a dedicated form in the system. The input data includes the date and time of the incident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery. This data provides basic information about the incident. When the input data is sent to the form, the terminal receives and temporarily stores the data.

[0783] Step 2:

[0784] The terminal verifies the accident data entered by the user. Specifically, it checks whether all required fields are filled in and whether the date and time format is correct. For example, it checks whether the date and time of the accident was entered in the format "mm / dd / yyyy hh:mm." If an error is detected during this verification step, the terminal displays an error message to the user and prompts them to re-enter the data. If the input is correct, the data passes the format check and is sent to the server.

[0785] Step 3:

[0786] The server receives the accident data that has been confirmed to be in the correct format and stores it in a database. The database stores information such as the identifier of each accident report, the date and time of the incident, the person who made the report, and the department in charge. The input to this step is the accident data sent from the terminal, and the output is the accident data stored in the database.

[0787] Step 4:

[0788] The server extracts accident data from the database and sends it to a natural language processing (NLP) model to analyze the accident details. The input is the acquired text data, and the output is a list of keywords indicating the extracted causes and effects. For example, the keyword "database connection error" is extracted.

[0789] Step 5:

[0790] The server uses a clustering algorithm to classify similar accidents based on the keywords extracted from the NLP model. The input is a list of keywords generated by the NLP model, and the output is a set of clusters of similar accidents. This allows accidents caused by the same reasons to be grouped together.

[0791] Step 6:

[0792] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures. The input is the clustered accidents, their causes, and countermeasures, and the output is learning content (text, diagrams, checklists, etc.). For example, content containing detailed explanations on "countermeasures for database connection errors" is generated.

[0793] Step 7:

[0794] The server also automatically generates test questions to test comprehension based on the generated learning content. The input is the generated learning content, and the output is multiple-choice questions, word fill-in-the-blank questions, and question-and-answer style test questions. As a specific example, a multiple-choice question such as "What is the cause of the database connection error?" is created.

[0795] Step 8:

[0796] The server distributes the generated learning content and test questions to the relevant users. Notifications are sent via the company's internal messaging system or email. The input is the learning content and test questions, and the output is the notification message. The terminal receives this and displays a pop-up or notification to the user.

[0797] Step 9:

[0798] The device uses an emotion engine to recognize the user's facial expressions and voice during training and testing. The input is video and audio data captured by a camera and microphone, and the output is recognized emotion data. For example, if the user is confused, that emotion data is collected.

[0799] Step 10:

[0800] The server analyzes the emotional data obtained from the emotion engine and automatically adjusts the difficulty level of the learning content and additional explanations. The input is emotional data, and the output is a specific action such as "display a link to additional explanations."

[0801] Step 11:

[0802] The user actually views the learning content that has been notified to them. By accessing it from their device, they can proceed with their learning through a web browser or dedicated application. The input is a request to access the learning content, and the output is the displayed learning content.

[0803] Step 12:

[0804] After studying, users answer test questions on their devices. The answers are sent to the server in real time, and the test is evaluated. The input is the user's answer data, and the output is the test results.

[0805] Step 13:

[0806] The server integrates the received test results and emotional data to evaluate the overall level of understanding. The results are displayed on a dashboard for administrator confirmation. The input is the test results and emotional data, and the output is an evaluation report and dashboard display.

[0807] Step 14:

[0808] The server notifies the user of additional follow-up study or retesting as necessary. The input is the evaluation result, and the output is a notification of follow-up study or retesting. For example, a notification such as "Please conduct additional study" is sent to a user who did not understand the material sufficiently.

[0809] Prompt Sentence Examples

[0810] We recently had an incident in our internal system. Please input the details of this incident, analyze it, and generate appropriate learning content and test questions.

[0811] (Application example 2)

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

[0813] Systems for preventing accidents and efficiently sharing knowledge in factories require the collection of accident data, analysis of causes, generation and distribution of effective learning content, recognition of user emotions, and real-time adjustment of learning content. Accidents have a significant impact on production efficiency, particularly in factory environments, so it is essential to quickly and accurately identify the causes of accidents and share related knowledge. Furthermore, to increase employees' motivation and understanding, it is necessary to introduce emotion recognition and provide individually optimized learning experiences.

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

[0815] In this invention, the server includes a means for collecting accident data, a means for analyzing the accident data to extract causes of accidents and countermeasures, and a means for automatically generating learning content based on the extracted causes and countermeasures. This enables rapid and accurate identification of accident causes. The server also includes a means for automatically generating test questions to test comprehension based on the learning content, a means for automatically distributing the automatically generated learning content and test questions to relevant users, a means for users to study and test, a means for collecting and evaluating users' test results, a means for identifying users' emotions using an emotion engine and adjusting the content of the learning content and tests based on the emotions, and a means for providing robots and sensors for collecting accident data in a factory environment, analyzing the data collected by the robots, and generating and distributing learning content. This provides an optimized learning experience for each employee, thereby preventing accidents and improving the efficiency of knowledge sharing throughout the factory.

[0816] "Incident Data" means information relating to an accident that occurred in a factory or other environment, including the date and time of the accident, its cause, the extent of its impact, and remediation measures.

[0817] "Analysis" refers to the analytical methods used to identify causes and countermeasures from collected accident data. This analysis uses technologies such as natural language processing and image recognition.

[0818] "Learning content" refers to educational materials generated from accident data, including text explanations, diagrams, and checklists.

[0819] "Test questions" are questions that test a user's understanding of the learning content. These questions include multiple choice questions and fill-in-the-blank questions.

[0820] An "emotion engine" is software that identifies emotions from a user's facial expressions and voice. This engine is used to improve the effectiveness of learning content and tests.

[0821] "Robots" are automated machinery used to collect and analyze incident data in factory environments, including through video capture and sensor data collection.

[0822] A "sensor" is a device that detects the physical conditions of the environment (temperature, pressure, humidity, etc.) and collects that data. It is used to identify accidents and analyze their causes.

[0823] A "natural language processing model" is an algorithm for analyzing text data and extracting specific information (such as causes and countermeasures). This model uses AI technology to understand the text.

[0824] A "generative AI model" is an artificial intelligence technology that automatically generates learning content and test questions based on accident data. This model generates content based on input data.

[0825] "Automated Delivery" means the automatic transmission of generated learning content and test questions to relevant users via internal messaging systems and / or email.

[0826] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in factories. The system collects and analyzes accident data, and automatically generates learning content and test questions based on that data and delivers them to users. It also has the ability to identify user emotions using an emotion engine and adjust the content of the learning process accordingly.

[0827] Accident data collection

[0828] When an accident occurs in a factory, the user provides details to the system using a dedicated form or voice input. At this time, the robot uses environmental sensors and CCTV cameras to collect video and physical data from the accident site. This data is collected and verified in real time by a mini server, such as the NVIDIA Jetson series.

[0829] Analysis of the accident

[0830] The server stores the accident data in a database and analyzes the text data using a natural language processing model (e.g., OpenAI GPT-4). This identifies the cause of the accident and countermeasures, and extracts highly relevant keywords. Furthermore, image recognition algorithms such as the YOLO series are used to detect anomalies in the video data.

[0831] Automatic generation of learning content and test questions

[0832] Based on the analysis results, the server uses a generative AI model (e.g., GPT-4) to automatically generate learning content. This content includes detailed explanations of the causes of accidents and countermeasures, diagrams, checklists, etc. Test questions are also automatically generated, including multiple-choice and fill-in-the-blank questions.

[0833] Automatic sharing and notifications

[0834] The server automatically distributes the generated learning content and test questions to relevant users via the company's internal messaging system, email, kiosk terminals in the factory, and smartphone apps.

[0835] Use of emotion engine

[0836] The server uses an emotion engine (e.g., Affectiva) to identify emotions from the user's facial expressions and voice during learning and testing, allowing it to adjust the difficulty and content of the learning content in real time, and provide additional explanations if the user is confused, for example.

[0837] Study and test

[0838] Users can view the delivered learning content on their devices, study, and then answer test questions, with the test results sent to the server in real time.

[0839] Test result evaluation and follow-up

[0840] The server aggregates test results and emotion data to evaluate the user's level of understanding. Based on the evaluation results, instructions for additional study or retesting are automatically sent as needed. This allows for quick response even if the user's understanding is insufficient.

[0841] Specific examples

[0842] For example, if an accident occurs in a factory due to a machine malfunction, the user enters the details of the accident into the system (e.g., "The production line stopped due to a machine malfunction. The cause was a sensor failure. The response was to replace the sensor and perform regular maintenance"). The server analyzes this and identifies "machine malfunction" as the cause and "sensor replacement and regular maintenance" as the response.

[0843] The server then uses the generative AI model to automatically generate learning content and test questions related to "procedures to prevent operational errors" and "regular maintenance techniques." These content and test questions are then distributed to the relevant employee's devices, where the user studies and takes the test. During this process, the emotion engine recognizes the user's emotions and adjusts the learning content as necessary.

[0844] Examples of prompt statements

[0845] "Accident report: A machine malfunction caused the production line to stop. The cause was a sensor failure. The solution was to replace the sensor and perform regular maintenance."

[0846] "Based on the above situation, please generate learning content and test questions related to safety management."

[0847] This invention automates the safety management and knowledge sharing process within factories, providing employees with quick and effective accident prevention measures. Individual adjustments using an emotion engine can also improve learning effectiveness.

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

[0849] Step 1: Collect accident data

[0850] When an accident occurs, the user enters details of the accident into the system using a dedicated form or voice input. The input includes the date and time of the accident, the location, a detailed description of the situation, the cause, and initial response measures. The robot also uses environmental sensors and CCTV cameras to collect video and physical data from the accident site. This allows accident data to be collected in real time.

[0851] Input: Accident details (date, time, location, explanation of the situation, cause, initial response measures), environmental sensor data, CCTV footage

[0852] Output: Accident dataset

[0853] Step 2: Review and save your data

[0854] The terminal checks the accident data collected from the user and robot, verifying that required fields have been filled in and that the data format is correct. If there are any errors, it notifies the user with a message and prompts them to correct the errors. If there are no errors, it sends the data to the server, which then stores the received data in a database.

[0855] Input: Accident dataset

[0856] Output: Confirmed accident data, error message (if necessary)

[0857] Step 3: Analysis of the accident

[0858] The server retrieves the stored accident data from the database and analyzes the text data using a natural language processing model (e.g., OpenAI GPT-4). The model extracts causes and effects from the text data and identifies relevant keywords. It also analyzes video data using image recognition algorithms such as the YOLO series to detect anomalies.

[0859] Input: Confirmed accident data

[0860] Output: Accident cause analysis results, related keywords, anomaly detection results

[0861] Step 4: Automatic generation of learning content and test questions

[0862] Based on the analysis results, the server automatically generates learning content and test questions using a generative AI model (e.g., GPT-4). The learning content includes detailed explanations of the causes of accidents and countermeasures, as well as diagrams and checklists, while the test questions include multiple-choice and fill-in-the-blank questions.

[0863] Input: Accident cause analysis results, related keywords, anomaly detection results

[0864] Output: Learning content, test questions

[0865] Step 5: Automated Delivery

[0866] The server automatically distributes the generated learning content and test questions based on the associated user list via the company's internal messaging system, email, factory kiosks, and smartphone apps.

[0867] Input: learning content, test questions

[0868] Output: Delivery notification (internal messaging, email, app notification)

[0869] Step 6: Training and testing

[0870] The user receives a notification of delivery, browses the learning content on their device, studies, and then answers the test questions. The test answers are sent to the server in real time.

[0871] Input: Delivery notification

[0872] Output: Test answer

[0873] Step 7: Collect emotion data

[0874] During training and testing, the device uses an emotion engine (e.g., Affectiva) to collect emotion data from the user's facial expressions and voice, which is then transmitted to the server in real time.

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

[0876] Output: Emotion data

[0877] Step 8: Evaluate test results and sentiment data

[0878] The server aggregates test answers and emotional data to evaluate the user's level of understanding and emotional state, and based on the evaluation results, it readjusts the learning content or provides instructions for additional learning.

[0879] Input: Test answers, emotion data

[0880] Output: Comprehension assessment results, readjustment instructions, additional study instructions

[0881] Step 9: Follow up

[0882] Based on the evaluation results, the server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action to be taken even if the user's understanding is insufficient.

[0883] Input: Comprehension assessment results, readjustment instructions, additional study instructions

[0884] Output: Follow-up notification (re-learning, re-test instructions)

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

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

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

[0888] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0901] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in large development organizations. Below, we will explain the program processing of this system in natural language, and provide concrete examples.

[0902] System Overview

[0903] This system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users, thereby quickly sharing knowledge for accident prevention. The entire system is mainly composed of a server, terminals, and users.

[0904] Accident data collection

[0905] 1. When an accident occurs, the user enters the accident data into a form for entering details of the accident. The accident data includes the date and time of the accident, the extent of the impact, the cause, specific details of the problem, and countermeasures.

[0906] 2. The terminal checks the format of the entered accident data and performs error checking to notify of input errors if necessary.

[0907] 3. The server stores the correctly formatted accident data in a database for later analysis.

[0908] Analysis of the accident

[0909] 1. The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, thereby extracting the causes of the accident and countermeasures.

[0910] 2. The server uses a clustering algorithm to group accident data with similar causes and countermeasures and organize the analysis results.

[0911] Automatic generation of learning content and test questions

[0912] 1. The server uses a generative AI model to automatically generate learning content from the analysis results, including text, diagrams, and checklists, with detailed explanations of specific examples and countermeasures.

[0913] 2. The server then automatically generates test questions based on the generated learning content to test comprehension, including multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[0914] Automatic sharing and notifications

[0915] 1. The server automatically distributes the generated learning content and test questions to a list of relevant users via an internal messaging system or email.

[0916] 2. The device sends a notification to the user so that they can access the delivered learning content and test questions.

[0917] Study and test

[0918] 1. Users receive a notification and can view the learning content on their device. The learning content can be easily accessed through a web browser or dedicated application.

[0919] 2. After studying, the user answers test questions on their device. The test results are sent to the server in real time.

[0920] Test result evaluation and follow-up

[0921] 1. The server aggregates the received test results and evaluates each user's level of understanding. The results are displayed on a dashboard so that administrators can check their progress.

[0922] 2. The server will then provide instructions for follow-up study as needed, and may automatically notify students of retests or additional assignments.

[0923] Specific examples

[0924] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. Next, the server uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and takes the test, and their level of understanding is evaluated. Based on the results of the evaluation, the server notifies them of additional learning as necessary.

[0925] This will enable efficient sharing of knowledge and effectively prevent accidents from occurring again.

[0926] The processing flow will be explained below.

[0927] Step 1:

[0928] When an accident occurs, users enter a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The form includes detailed information such as the date and time of the accident, the names of the affected systems and modules, specific details of the problem, and the time until recovery.

[0929] Step 2:

[0930] The terminal checks the entered accident data to see if there are any errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[0931] Step 3:

[0932] The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[0933] Step 4:

[0934] The server runs a natural language processing (NLP) model to analyze the stored accident data, extracting causes and effects from the text data and identifying relevant keywords.

[0935] Step 5:

[0936] Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of accidents, which allows accidents with similar causes and countermeasures to be grouped together and classified.

[0937] Step 6:

[0938] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures, including text, diagrams, and checklists related to the causes of accidents and countermeasures.

[0939] Step 7:

[0940] The server automatically generates test questions based on the learning content, including multiple choice, word fill-in-the-blank, and question-and-answer formats, that match the generated content.

[0941] Step 8:

[0942] The server automatically distributes the generated learning content and test questions to relevant users, including departments affected by the incident and members of related teams.

[0943] Step 9:

[0944] The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[0945] Step 10:

[0946] Users receive notifications and can view the learning content through a web interface or dedicated application on their device. The learning content is easily accessible and intuitive to use.

[0947] Step 11:

[0948] After studying, users answer test questions on their devices, and the answers are sent to the server in real time.

[0949] Step 12:

[0950] The server aggregates the received test results and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard and can be checked by an administrator.

[0951] Step 13:

[0952] The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even if the user's understanding is insufficient.

[0953] Example 1

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

[0955] When an accident occurs in a large development organization, it is necessary to quickly and effectively share the cause and countermeasures. However, with conventional methods, collecting and analyzing accident data takes time, which often delays the sharing of knowledge. In addition, manually creating learning content and test questions requires a great deal of effort, resulting in a decrease in the effectiveness of education. A system is needed to solve these issues and efficiently prevent accidents and share knowledge.

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

[0957] In this invention, the server includes means for collecting accident data, means for checking the format of the collected accident data and notifying of input errors, means for analyzing the accident data to extract causes of the accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to relevant users, means for users to study and test, means for collecting and evaluating user test results, and means for instructing additional follow-up study based on the evaluation results. This enables the entire process from collecting accident data to automatically generating, distributing, and evaluating learning content and test questions to be carried out efficiently.

[0958] "Accident data" is data collected when an accident occurs, including information such as the date and time of the accident, the extent of the impact, the cause, the specific details of the problem, and countermeasures.

[0959] The "means of collection" refers to the means by which accident data is input by users and then imported into the system.

[0960] The "means for checking the format and notifying of input errors" refers to a means for checking whether the values ​​in each field of the collected accident data are in the appropriate format, and for prompting the user to re-enter the data if there is an error.

[0961] "Means of analyzing and extracting the causes of accidents and countermeasures" refers to analyzing collected accident data using natural language processing models, etc., and extracting the causes of accidents and countermeasures.

[0962] "Means for automatically generating learning content" refers to a means for automatically generating content (text, illustrations, checklists, etc.) for users to study based on the analysis results using a generative AI model.

[0963] "Means for automatically generating test questions to test comprehension" refers to a means for automatically generating test questions (multiple choice questions, fill-in-the-blank questions, question-and-answer questions, etc.) to evaluate a user's level of comprehension based on the generated learning content.

[0964] The "means for automatically distributing automatically generated learning content and test questions to relevant users" refers to a means for automatically distributing the generated learning content and test questions to relevant users.

[0965] "Means for learning and testing" refers to the means by which a user can view learning content and answer test questions.

[0966] The "means for collecting and evaluating test results" refers to a means for aggregating test results sent by users and evaluating the level of understanding of each user.

[0967] The "means for instructing additional follow-up study" refers to a means for instructing the user on necessary additional study based on the evaluation of the test results, and for notifying the user of retests or additional assignments.

[0968] This invention is a system for efficiently preventing accidents and sharing knowledge in large development organizations. This system collects and analyzes accident data, automatically generates learning content and test questions based on the data, and distributes them to users, thereby quickly sharing knowledge for preventing accidents. The entire system is mainly composed of a server, terminals, and users.

[0969] An embodiment of the system will now be described in detail.

[0970] First, when an accident occurs, the user accesses a dedicated form and enters the accident data (date and time of occurrence, extent of impact, cause, specific details of the failure, countermeasures, etc.). For example, this can be done using a web browser. After the user has completed the input, they press the send button, which sends the data to the server.

[0971] The terminal receives this data and performs a format check. For example, it checks whether the date and time information is in the "YYYY-MM-DD" format. If there is an error in the input, it displays an error message to the user and prompts them to re-enter the information.

[0972] The server stores the correct formatted accident data sent from the device in a database (for example, MySQL) for later analysis.

[0973] The server retrieves accident data from the database and analyzes the text data using a natural language processing (NLP) model (e.g., BERT), thereby extracting the causes of the accident and countermeasures.

[0974] The server then uses a clustering algorithm (e.g., K-means) to group incident data with the same causes and countermeasures, making it easier to identify similar patterns.

[0975] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content from the analysis results. For example, it generates learning materials such as best practices and checklists for the extracted "lack of review." The server then automatically generates test questions (multiple choice questions, fill-in-the-blank questions, question-and-answer questions, etc.) to test comprehension based on the generated learning content.

[0976] The server automatically distributes these learning contents and test questions to relevant users, for example, via an internal messaging system (e.g., Slack) or email.

[0977] The device notifies the user when new learning content and test questions have been distributed. The user receives the notification and accesses the learning content from their device (PC or smartphone). The learning content can be easily accessed through a web browser or dedicated application.

[0978] Users study the content and answer test questions. The test results are sent in real time to the server, which then aggregates them and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard, allowing administrators to monitor progress.

[0979] Based on the evaluation results, the server automatically recommends additional follow-up learning, and will also notify students of retests or additional assignments as necessary.

[0980] As a specific example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident. The device performs a format check and, if no errors are found, sends the data to the server. The server uses a natural language processing model to identify "insufficient reviews" as the cause and "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the devices of the relevant developers, and the users study and take the test, with their level of understanding being evaluated by the server. Depending on the evaluation results, the server notifies them of additional learning as necessary.

[0981] An example of a prompt is, "Please explain the cause and solution of a system outage that occurred in a certain development team. Also, please generate appropriate learning content and test questions based on that." This system will enable efficient knowledge sharing and the prevention of accident recurrence.

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

[0983] Step 1:

[0984] When an accident occurs, the user accesses a dedicated form and enters the accident data (date and time of occurrence, extent of impact, cause, specific details of the problem, countermeasures, etc.). After completing the input, the user clicks the send button.

[0985] Input: Accident data (occurrence date and time, extent of impact, cause, specific details of the failure, countermeasures)

[0986] Output: Accident data entered into the form

[0987] Step 2:

[0988] The terminal receives the transmitted accident data and performs format checks, for example, checking that the date field is in "YYYY-MM-DD" format, and if there is an error, it displays an error message to the user and asks them to re-enter the data.

[0989] Input: Accident data submitted via the form

[0990] Output: Correctly formatted incident data or an error message

[0991] Step 3:

[0992] The server stores the correct formatted accident data sent from the device in a database (e.g., MySQL).

[0993] Input: Accident data that passes format check

[0994] Output: Accident data stored in a database

[0995] Step 4:

[0996] The server retrieves accident data from the database, analyzes the text data using a natural language processing (NLP) model (e.g., BERT), and extracts the causes of the accident and countermeasures.

[0997] Input: Accident data retrieved from the database

[0998] Output: Extracted causes of accidents and countermeasures

[0999] Step 5:

[1000] The server uses a clustering algorithm (e.g., K-means) to group similar data based on the analyzed causes and countermeasures of the accident.

[1001] Input: Extracted cause and countermeasure data

[1002] Output: Clustered accident data

[1003] Step 6:

[1004] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content from the clustering results, such as best practices for review gaps and checklists to prevent similar incidents from occurring.

[1005] Input: Clustering results

[1006] Output: Auto-generated learning content

[1007] Step 7:

[1008] The server automatically generates test questions to assess comprehension based on the generated learning content, including multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[1009] Input: Learning content

[1010] Output: Auto-generated test questions

[1011] Step 8:

[1012] The server automatically distributes the generated learning content and test questions to relevant users, for example, via an internal messaging system (e.g., Slack) or email.

[1013] Input: Learning content and test questions

[1014] Output: Delivery notification to user

[1015] Step 9:

[1016] The device will notify the user when new learning content and test questions are available via pop-ups, push notifications, emails, etc.

[1017] Input: Delivery notification from the server

[1018] Output: A message to inform the user

[1019] Step 10:

[1020] Users receive a notification and can access the learning content from their device (PC or smartphone) via a web browser or dedicated application.

[1021] Input: Delivered learning content

[1022] Output: User learning activity

[1023] Step 11:

[1024] After studying, users answer test questions using their devices, and the test results are sent to the server in real time.

[1025] Input: Answer to test question

[1026] Output: Test results sent in real time

[1027] Step 12:

[1028] The server aggregates the received test results and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard so that administrators can check their progress.

[1029] Input: Test result data

[1030] Output: Aggregated evaluation results and dashboard display

[1031] Step 13:

[1032] Based on the evaluation results, the server automatically recommends additional follow-up learning as needed, and also notifies students of retests and additional assignments.

[1033] Input: Aggregated evaluation results

[1034] Output: Notifications for follow-up study and retesting

[1035] (Application example 1)

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

[1037] Accidents in factories threaten the safety of workers and reduce productivity. Conventional systems tend to be slow to share knowledge to prevent accidents, and preventive measures are not quickly implemented. For this reason, there is a need for a system that can quickly and efficiently collect and analyze accident data, automatically generate appropriate learning content and test questions based on that data, and quickly share them with workers and robots.

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

[1039] In this invention, the server includes means for collecting accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to related workers and robots, means for workers to study and test, and means for collecting and evaluating test results. This allows knowledge on accident prevention to be shared quickly and efficiently, making it possible to prevent accidents from recurring at factory sites.

[1040] "Accident data" refers to detailed information about accidents that occur within a factory, including the date and time of the accident, the extent of the impact, the cause, the specific details of the problem, and countermeasures.

[1041] A "natural language processing model" refers to algorithms and techniques that allow computers to understand, analyze, and generate human language, providing a means of extracting meaning and context from text.

[1042] A "generative AI model" is an algorithm that uses machine learning to automatically generate new content and data, generating text, images, audio, etc. based on given input.

[1043] "Learning content" refers to learning materials for acquiring specific knowledge or skills, and includes text, illustrations, checklists, etc.

[1044] "Test questions" are questions or tasks used to assess a user's understanding of the learning content, and may include multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[1045] A "robot" is a mechanical device that automatically performs specific tasks or operations in a factory, helping to prevent accidents and share knowledge.

[1046] The "Factory Robot Support System" is an integrated system for collecting and analyzing accident data, generating and distributing learning content, generating test questions, and providing these to workers and robots.

[1047] As an embodiment of the present invention, the following factory robot support system is provided. The entire system is mainly composed of a server, terminals, and users (workers and robots). How each component of the system interacts and functions will be explained below.

[1048] System Overview

[1049] This factory robot support system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users and robots, thereby quickly sharing knowledge to prevent accidents.

[1050] Hardware and Software

[1051] Hardware

[1052] Factory robot: A device with an interface that allows workers to easily input accident data and share knowledge about accident prevention.

[1053] Server: Provides infrastructure for database management, natural language processing analysis, and generative AI model operation.

[1054] software

[1055] Natural language processing (NLP) engine: Used to analyze text data, and specific technologies include models such as BERT and GPT-3.

[1056] Clustering algorithms: Used to group accident data with similar causes and countermeasures, specific techniques include k-means.

[1057] Generative AI models: Used to automatically generate learning content and test questions; specific technologies include OpenAI's GPT-3.

[1058] Program processing explanation

[1059] 1. Entering accident data and checking for errors

[1060] When an accident occurs, the user inputs details of the accident into a terminal built into the factory robot, which then checks the input data for incomplete data or input errors.

[1061] 2. Accident data storage

[1062] Correctly formatted accident data is sent to a server and stored in a database for later analysis.

[1063] 3. Analysis of the accident

[1064] The server retrieves the accident data from the database, performs text analysis using natural language processing techniques (e.g., BERT or GPT-3), and then groups the accident data using a clustering algorithm (e.g., k-means).

[1065] 4. Automatic generation of learning content and test questions

[1066] Generative AI models (e.g., GPT-3) are used to generate learning content from the analysis results, including text, diagrams, checklists, etc. Test questions are also automatically generated to test comprehension.

[1067] 5. Delivery and Notification

[1068] The generated learning content and test questions are automatically distributed by the server to the relevant workers and robots via the factory messaging system or email, and notifications are sent by the terminals.

[1069] 6. Implementation of learning

[1070] The worker receives a notification and views the learning content on their device. After studying, they take a test, and the test results are sent to the server in real time.

[1071] 7. Evaluation and follow-up of test results

[1072] The server aggregates the received test results and evaluates each worker's level of understanding. The results are displayed on a dashboard, allowing managers to check progress and, if necessary, instruct additional follow-up learning.

[1073] Specific examples

[1074] For example, if a collision occurs while operating a forklift in a factory, the worker uses the robot's interface to input details of the accident. The server analyzes this data, identifies "misoperation of the forklift" as the cause, and extracts "improvement of operating techniques" as the countermeasure. Next, it uses a generative AI model to generate learning content on "safe forklift operation methods" and test questions on "risks caused by operating errors." These content and test questions are then distributed to the relevant workers and robots.

[1075] Example prompt for a generative AI model:

[1076] "Please create learning content that instructs students on how to improve their driving techniques regarding collision accidents that occurred due to forklift driving errors, and create test questions to measure their understanding."

[1077] This will enable accident prevention knowledge to be shared effectively within the factory, preventing recurrence.

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

[1079] Step 1: Enter accident data and check for errors

[1080] The user inputs details of the accident into a terminal built into the factory robot. The terminal receives the input accident data (date and time of occurrence, extent of impact, cause, specific details of the problem, and countermeasures) and checks for incomplete data or input errors. For example, if the date and time are inaccurate, a warning is displayed, prompting correction.

[1081] Input: Accident details

[1082] Output: Well-formatted incident data or error messages

[1083] Step 2: Save the incident data

[1084] Accident data in the correct format is sent from the device to the server, which then stores the received data in a database for later analysis.

[1085] Input: Correctly formatted accident data

[1086] Output: Accident data stored in a database

[1087] Step 3: Analysis of the accident

[1088] The server retrieves accident data from the database, performs text analysis using natural language processing techniques (e.g., BERT or GPT-3) to extract accident causes and countermeasures, and then uses a clustering algorithm (e.g., k-means) to group accident data with similar causes and countermeasures.

[1089] Input: Accident data retrieved from the database

[1090] Output: Analysis results (causes of accidents and countermeasures), grouped accident data

[1091] Step 4: Automatic generation of learning content and test questions

[1092] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content based on the causes and countermeasures of accidents. This content includes text, diagrams, checklists, etc. At the same time, test questions are automatically generated to test comprehension.

[1093] Input: Analysis results (cause of accident and countermeasures)

[1094] Output: Auto-generated learning content, test questions

[1095] Step 5: Delivery and Notification

[1096] The server automatically distributes the generated learning content and test questions to the relevant workers and robots via the factory's messaging system or email, and the terminals send notifications. Specifically, each worker receives a notification message containing a link to the content.

[1097] Input: learning content, test questions

[1098] Output: Auto-distributed content and notification messages

[1099] Step 6: Learning

[1100] The user receives a notification and views the learning content on their device. After viewing the learning content, the worker answers the test questions on their device. The test results are sent to the server in real time.

[1101] Input: learning content, test questions

[1102] Output: Answered test results (sent in real time)

[1103] Step 7: Evaluate and follow up on test results

[1104] The server aggregates the received test results and evaluates each user's level of understanding. The results are displayed on a dashboard so administrators can check progress and automatically recommend additional follow-up learning if necessary.

[1105] Input: Test result

[1106] Output: Assessment results, dashboard display, and instructions for further follow-up

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

[1108] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in large development organizations, and by combining it with user emotion recognition, it improves the effectiveness of the learning process. Below, we will explain the program processing of this system in natural language, and provide concrete examples.

[1109] System Overview

[1110] This system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users, quickly sharing knowledge for accident prevention. It also uses an emotion engine to recognize user emotions and improve the effectiveness of the learning content and tests. The entire system is primarily composed of a server, terminals, and users.

[1111] Accident data collection

[1112] 1. When an accident occurs, the user enters a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The accident data includes detailed information such as the date and time of the accident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery.

[1113] 2. The terminal checks the entered accident data and checks for errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[1114] 3. The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[1115] Analysis of the accident

[1116] 1. The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, which extracts causes and effects from the text data and identifies relevant keywords.

[1117] 2. Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of the accidents, thereby grouping accident data with similar causes and countermeasures and classifying the accidents.

[1118] Automatic generation of learning content and test questions

[1119] 1. The server uses the generative AI model to automatically generate learning content based on the extracted causes and countermeasures. The generated content includes text, diagrams, checklists, etc. related to the causes of accidents and countermeasures.

[1120] 2. The server automatically generates test questions based on the learning content to test comprehension, including multiple choice questions, word fill-in-the-blank questions, and question-and-answer questions, and these questions match the generated content.

[1121] Automatic sharing and notifications

[1122] 1. The server automatically distributes the generated learning content and test questions to the relevant user list via the company's internal messaging system or email.

[1123] 2. The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[1124] Use of emotion engine

[1125] 1. The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing. For example, changes in facial expressions when viewing learning content, or voice tones when answering test questions.

[1126] 2. The server analyzes the user's emotional data recognized by the emotion engine and adjusts the difficulty and content of the learning content accordingly. For example, if the user is confused, it will provide additional explanations.

[1127] 3. The server reflects the emotional data in the evaluation of the test results, enabling a more accurate assessment of the user's comprehension level, thereby enabling a comprehensive assessment of the user's actual comprehension level and emotional state.

[1128] Study and test

[1129] 1. Users receive a notification and can view the learning content on their device. The learning content can be easily accessed through a web browser or dedicated application.

[1130] 2. After studying, the user answers test questions on the device, and the test answers are sent to the server in real time.

[1131] Test result evaluation and follow-up

[1132] 1. The server aggregates the received test results and evaluates each user's level of understanding and emotional data. The evaluation results are displayed on a dashboard and can be confirmed by an administrator.

[1133] 2. The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even when the user's understanding is insufficient.

[1134] Specific examples

[1135] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning and testing, the device uses an emotion engine to collect user emotional data, which the server analyzes and adjusts the learning content as needed. Based on the evaluation results, the server notifies the user of additional learning as needed.

[1136] This enables efficient knowledge sharing, effectively prevents accidents from recurring, and provides a learning experience that takes users' emotions into consideration.

[1137] The processing flow will be explained below.

[1138] Step 1:

[1139] When an accident occurs, users enter a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The form includes detailed information such as the date and time of the accident, the names of the affected systems and modules, specific details of the problem, and the time until recovery.

[1140] Step 2:

[1141] The terminal checks the entered accident data to see if there are any errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[1142] Step 3:

[1143] The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[1144] Step 4:

[1145] The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, which extracts causes and effects from the text data and identifies relevant keywords.

[1146] Step 5:

[1147] Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of accidents, thereby grouping accident data with similar causes and countermeasures and classifying the accidents.

[1148] Step 6:

[1149] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures, including text, diagrams, and checklists related to the causes of accidents and countermeasures.

[1150] Step 7:

[1151] The server automatically generates test questions based on the learning content, including multiple choice, word fill-in-the-blank, and question-and-answer formats, that match the generated content.

[1152] Step 8:

[1153] The server automatically distributes the generated learning content and test questions to the relevant user list via the company's internal messaging system or email.

[1154] Step 9:

[1155] The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[1156] Step 10:

[1157] The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing, such as changes in facial expressions when viewing learning content or voice tones when answering test questions.

[1158] Step 11:

[1159] The server analyzes the user's emotional data recognized by the emotion engine and adjusts the difficulty and content of the learning content accordingly. For example, if the user is confused, it will provide additional explanations.

[1160] Step 12:

[1161] Users receive notifications and can view the learning content on their devices, which can be easily accessed through a web browser or dedicated application.

[1162] Step 13:

[1163] After studying, users answer test questions on their devices, and the answers are sent to the server in real time.

[1164] Step 14:

[1165] The server aggregates the received test results and evaluates each user's level of understanding and emotional data. The evaluation results are displayed on a dashboard and can be checked by an administrator.

[1166] Step 15:

[1167] The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even if the user's understanding is insufficient.

[1168] Examples:

[1169] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning and testing, the device uses an emotion engine to collect user emotional data, which the server analyzes and adjusts the learning content as needed. Based on the evaluation results, the server notifies the user of additional learning as needed.

[1170] Example 2

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

[1172] Large development organizations are seeking systems that can prevent accidents and share knowledge quickly and efficiently. Furthermore, existing learning systems do not take users' emotions into account, making effective learning difficult and preventing improvements in understanding. The present invention aims to solve these problems and provide an effective learning system that takes users' emotions into account.

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

[1174] In this invention, the server includes means for collecting accident data, means for verifying the collected accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for analyzing the collected accident data using a natural language processing model, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating learning content using a generative AI model, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the generated learning content and test questions to relevant users, means for recognizing user emotions using an emotion engine, means for adjusting the learning content based on the recognized emotion data, means for users to study and test, and means for collecting and evaluating user test results and emotion data. This enables the prevention of accident recurrence, the rapid sharing of knowledge, and effective learning that takes user emotions into consideration.

[1175] "Accident data" refers to detailed information about an accident that has occurred, such as an overview, cause, impact, and countermeasures, that is entered into the system by the user.

[1176] "Means of collection" refers to the function of providing a dedicated form or interface for users to input accident data and importing that data into the system.

[1177] "Means of verification" refers to functions that check whether collected accident data has been entered correctly, whether required fields have been filled in, and whether the data format has been confirmed.

[1178] "Means of analysis" refers to the function of analyzing collected accident data using natural language processing (NLP) models, etc., to extract the causes of accidents and countermeasures.

[1179] A "natural language processing model" refers to algorithms and technologies for analyzing text data, understanding its meaning, and extracting important information.

[1180] "Means of extraction" refers to the function of deriving the cause of an accident and countermeasures from the analyzed data.

[1181] A "generative AI model" refers to artificial intelligence technology that automatically generates learning content and test questions based on input data.

[1182] "Learning content" refers to educational materials such as texts, charts, and checklists that contain information about the causes of accidents and countermeasures.

[1183] "Means for automatic generation" refers to the function of automatically creating learning content and test questions based on collected and analyzed data.

[1184] "Test questions" are a set of questions designed to test a user's level of understanding based on the learning content, and include multiple choice questions and fill-in-the-blank questions.

[1185] "Means for automatic distribution" refers to the function of automatically sending generated learning content and test questions to relevant users.

[1186] An "emotion engine" refers to the technology and algorithms used to analyze a user's facial expressions and voice to recognize their emotions.

[1187] "Emotional Data" refers to data regarding a user's emotional state collected using an emotion engine.

[1188] "Means of adjustment" refers to the function of appropriately changing the learning content, difficulty of test questions, etc. based on collected emotional data.

[1189] "User" means any individual or member of an organization who uses the System.

[1190] "Means of evaluation" refers to the function of compiling users' test results and emotional data to comprehensively assess their level of understanding.

[1191] The "system" refers to a comprehensive set of technologies and devices that combine the aforementioned measures to prevent accidents from recurring, share knowledge, and provide an effective learning experience.

[1192] This invention is a system that improves the efficiency of accident prevention and knowledge sharing in large development organizations, and further improves the effectiveness of the learning process by combining it with user emotion recognition. This system is mainly composed of a server, terminals, and users.

[1193] Accident data collection

[1194] The user enters details of the accident into a dedicated form in the system. The data to be entered includes the date and time of the accident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery. The terminal verifies the entered data, checking whether required fields have been filled in and whether the data format is correct. If there are any errors, an error message is displayed to the user. The server stores the accident data in a database once it has been confirmed to be in the correct format.

[1195] Analysis of the accident

[1196] The server retrieves accident data from the database and analyzes the text data using a natural language processing (NLP) model. The model extracts causes and effects from accident reports and identifies relevant keywords. It then uses a clustering algorithm to classify similar accidents and extract causes and countermeasures.

[1197] Automatic generation of learning content and test questions

[1198] The server uses a generative AI model to automatically generate learning content from the analysis results. The generated content includes text, diagrams, checklists, and other information related to the causes of accidents and countermeasures. Furthermore, test questions to test comprehension are automatically created based on the learning content. Test questions include multiple choice questions, word fill-in-the-blank questions, and question-and-answer format questions.

[1199] Automatic sharing and notifications

[1200] The server automatically distributes the generated learning content and test questions to relevant users via an internal messaging system or email. The device then notifies the user of the distributed content and test questions.

[1201] Use of emotion engine

[1202] The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing. For example, it monitors changes in facial expressions and tone of voice. The server analyzes the collected emotion data and adjusts the difficulty and content of the learning content accordingly. It can also provide additional explanations to confused users.

[1203] Study and test

[1204] Users receive notifications and can view the learning content on their devices via a web browser or dedicated application. After studying, users answer test questions, and their answers are sent to the server in real time.

[1205] Test result evaluation and follow-up

[1206] The server aggregates the test results and collected emotional data to evaluate each user's level of understanding. The evaluation results are displayed on a dashboard for administrators to review. If necessary, instructions for additional follow-up learning or retesting are automatically sent.

[1207] Specific examples

[1208] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server then uses a natural language processing model to identify "insufficient reviews" and recommends "strengthening reviews" as a countermeasure. The server then uses a generative AI model to automatically generate learning content on "best practices for code reviews" and create test questions on "risks caused by insufficient reviews." The content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning, the device uses an emotion engine to collect user emotion data, and the server sends additional learning instructions based on the analysis results.

[1209] Prompt Sentence Examples

[1210] We recently had an incident in our internal system. Please input the details of this incident, analyze it, and generate appropriate learning content and test questions.

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

[1212] Step 1:

[1213] The user enters incident data into a dedicated form in the system. The input data includes the date and time of the incident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery. This data provides basic information about the incident. When the input data is sent to the form, the terminal receives and temporarily stores the data.

[1214] Step 2:

[1215] The terminal verifies the accident data entered by the user. Specifically, it checks whether all required fields are filled in and whether the date and time format is correct. For example, it checks whether the date and time of the accident was entered in the format "mm / dd / yyyy hh:mm." If an error is detected during this verification step, the terminal displays an error message to the user and prompts them to re-enter the data. If the input is correct, the data passes the format check and is sent to the server.

[1216] Step 3:

[1217] The server receives the accident data that has been confirmed to be in the correct format and stores it in a database. The database stores information such as the identifier of each accident report, the date and time of the incident, the person who made the report, and the department in charge. The input to this step is the accident data sent from the terminal, and the output is the accident data stored in the database.

[1218] Step 4:

[1219] The server extracts accident data from the database and sends it to a natural language processing (NLP) model to analyze the accident details. The input is the acquired text data, and the output is a list of keywords indicating the extracted causes and effects. For example, the keyword "database connection error" is extracted.

[1220] Step 5:

[1221] The server uses a clustering algorithm to classify similar accidents based on the keywords extracted from the NLP model. The input is a list of keywords generated by the NLP model, and the output is a set of clusters of similar accidents. This allows accidents caused by the same reasons to be grouped together.

[1222] Step 6:

[1223] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures. The input is the clustered accidents, their causes, and countermeasures, and the output is learning content (text, diagrams, checklists, etc.). For example, content containing detailed explanations on "countermeasures for database connection errors" is generated.

[1224] Step 7:

[1225] The server also automatically generates test questions to test comprehension based on the generated learning content. The input is the generated learning content, and the output is multiple-choice questions, word fill-in-the-blank questions, and question-and-answer style test questions. As a specific example, a multiple-choice question such as "What is the cause of the database connection error?" is created.

[1226] Step 8:

[1227] The server distributes the generated learning content and test questions to the relevant users. Notifications are sent via the company's internal messaging system or email. The input is the learning content and test questions, and the output is the notification message. The terminal receives this and displays a pop-up or notification to the user.

[1228] Step 9:

[1229] The device uses an emotion engine to recognize the user's facial expressions and voice during training and testing. The input is video and audio data captured by a camera and microphone, and the output is recognized emotion data. For example, if the user is confused, that emotion data is collected.

[1230] Step 10:

[1231] The server analyzes the emotional data obtained from the emotion engine and automatically adjusts the difficulty level of the learning content and additional explanations. The input is emotional data, and the output is a specific action such as "display a link to additional explanations."

[1232] Step 11:

[1233] The user actually views the learning content that has been notified to them. By accessing it from their device, they can proceed with their learning through a web browser or dedicated application. The input is a request to access the learning content, and the output is the displayed learning content.

[1234] Step 12:

[1235] After studying, users answer test questions on their devices. The answers are sent to the server in real time, and the test is evaluated. The input is the user's answer data, and the output is the test results.

[1236] Step 13:

[1237] The server integrates the received test results and emotional data to evaluate the overall level of understanding. The results are displayed on a dashboard for administrator confirmation. The input is the test results and emotional data, and the output is an evaluation report and dashboard display.

[1238] Step 14:

[1239] The server notifies the user of additional follow-up study or retesting as necessary. The input is the evaluation result, and the output is a notification of follow-up study or retesting. For example, a notification such as "Please conduct additional study" is sent to a user who did not understand the material sufficiently.

[1240] Prompt Sentence Examples

[1241] We recently had an incident in our internal system. Please input the details of this incident, analyze it, and generate appropriate learning content and test questions.

[1242] (Application example 2)

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

[1244] Systems for preventing accidents and efficiently sharing knowledge in factories require the collection of accident data, analysis of causes, generation and distribution of effective learning content, recognition of user emotions, and real-time adjustment of learning content. Accidents have a significant impact on production efficiency, particularly in factory environments, so it is essential to quickly and accurately identify the causes of accidents and share related knowledge. Furthermore, to increase employees' motivation and understanding, it is necessary to introduce emotion recognition and provide individually optimized learning experiences.

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

[1246] In this invention, the server includes a means for collecting accident data, a means for analyzing the accident data to extract causes of accidents and countermeasures, and a means for automatically generating learning content based on the extracted causes and countermeasures. This enables rapid and accurate identification of accident causes. The server also includes a means for automatically generating test questions to test comprehension based on the learning content, a means for automatically distributing the automatically generated learning content and test questions to relevant users, a means for users to study and test, a means for collecting and evaluating users' test results, a means for identifying users' emotions using an emotion engine and adjusting the content of the learning content and tests based on the emotions, and a means for providing robots and sensors for collecting accident data in a factory environment, analyzing the data collected by the robots, and generating and distributing learning content. This provides an optimized learning experience for each employee, thereby preventing accidents and improving the efficiency of knowledge sharing throughout the factory.

[1247] "Incident Data" means information relating to an accident that occurred in a factory or other environment, including the date and time of the accident, its cause, the extent of its impact, and remediation measures.

[1248] "Analysis" refers to the analytical methods used to identify causes and countermeasures from collected accident data. This analysis uses technologies such as natural language processing and image recognition.

[1249] "Learning content" refers to educational materials generated from accident data, including text explanations, diagrams, and checklists.

[1250] "Test questions" are questions that test a user's understanding of the learning content. These questions include multiple choice questions and fill-in-the-blank questions.

[1251] An "emotion engine" is software that identifies emotions from a user's facial expressions and voice. This engine is used to improve the effectiveness of learning content and tests.

[1252] "Robots" are automated machinery used to collect and analyze incident data in factory environments, including through video capture and sensor data collection.

[1253] A "sensor" is a device that detects the physical conditions of the environment (temperature, pressure, humidity, etc.) and collects that data. It is used to identify accidents and analyze their causes.

[1254] A "natural language processing model" is an algorithm for analyzing text data and extracting specific information (such as causes and countermeasures). This model uses AI technology to understand the text.

[1255] A "generative AI model" is an artificial intelligence technology that automatically generates learning content and test questions based on accident data. This model generates content based on input data.

[1256] "Automated Delivery" means the automatic transmission of generated learning content and test questions to relevant users via internal messaging systems and / or email.

[1257] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in factories. The system collects and analyzes accident data, and automatically generates learning content and test questions based on that data and delivers them to users. It also has the ability to identify user emotions using an emotion engine and adjust the content of the learning process accordingly.

[1258] Accident data collection

[1259] When an accident occurs in a factory, the user provides details to the system using a dedicated form or voice input. At this time, the robot uses environmental sensors and CCTV cameras to collect video and physical data from the accident site. This data is collected and verified in real time by a mini server, such as the NVIDIA Jetson series.

[1260] Analysis of the accident

[1261] The server stores the accident data in a database and analyzes the text data using a natural language processing model (e.g., OpenAI GPT-4). This identifies the cause of the accident and countermeasures, and extracts highly relevant keywords. Furthermore, image recognition algorithms such as the YOLO series are used to detect anomalies in the video data.

[1262] Automatic generation of learning content and test questions

[1263] Based on the analysis results, the server uses a generative AI model (e.g., GPT-4) to automatically generate learning content. This content includes detailed explanations of the causes of accidents and countermeasures, diagrams, checklists, etc. Test questions are also automatically generated, including multiple-choice and fill-in-the-blank questions.

[1264] Automatic sharing and notifications

[1265] The server automatically distributes the generated learning content and test questions to relevant users via the company's internal messaging system, email, kiosk terminals in the factory, and smartphone apps.

[1266] Use of emotion engine

[1267] The server uses an emotion engine (e.g., Affectiva) to identify emotions from the user's facial expressions and voice during learning and testing, allowing it to adjust the difficulty and content of the learning content in real time, and provide additional explanations if the user is confused, for example.

[1268] Study and test

[1269] Users can view the delivered learning content on their devices, study, and then answer test questions, with the test results sent to the server in real time.

[1270] Test result evaluation and follow-up

[1271] The server aggregates test results and emotion data to evaluate the user's level of understanding. Based on the evaluation results, instructions for additional study or retesting are automatically sent as needed. This allows for quick response even if the user's understanding is insufficient.

[1272] Specific examples

[1273] For example, if an accident occurs in a factory due to a machine malfunction, the user enters the details of the accident into the system (e.g., "The production line stopped due to a machine malfunction. The cause was a sensor failure. The response was to replace the sensor and perform regular maintenance"). The server analyzes this and identifies "machine malfunction" as the cause and "sensor replacement and regular maintenance" as the response.

[1274] The server then uses the generative AI model to automatically generate learning content and test questions related to "procedures to prevent operational errors" and "regular maintenance techniques." These content and test questions are then distributed to the relevant employee's devices, where the user studies and takes the test. During this process, the emotion engine recognizes the user's emotions and adjusts the learning content as necessary.

[1275] Examples of prompt statements

[1276] "Accident report: A machine malfunction caused the production line to stop. The cause was a sensor failure. The solution was to replace the sensor and perform regular maintenance."

[1277] "Based on the above situation, please generate learning content and test questions related to safety management."

[1278] This invention automates the safety management and knowledge sharing process within factories, providing employees with quick and effective accident prevention measures. Individual adjustments using an emotion engine can also improve learning effectiveness.

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

[1280] Step 1: Collect accident data

[1281] When an accident occurs, the user enters details of the accident into the system using a dedicated form or voice input. The input includes the date and time of the accident, the location, a detailed description of the situation, the cause, and initial response measures. The robot also uses environmental sensors and CCTV cameras to collect video and physical data from the accident site. This allows accident data to be collected in real time.

[1282] Input: Accident details (date, time, location, explanation of the situation, cause, initial response measures), environmental sensor data, CCTV footage

[1283] Output: Accident dataset

[1284] Step 2: Review and save your data

[1285] The terminal checks the accident data collected from the user and robot, verifying that required fields have been filled in and that the data format is correct. If there are any errors, it notifies the user with a message and prompts them to correct the errors. If there are no errors, it sends the data to the server, which then stores the received data in a database.

[1286] Input: Accident dataset

[1287] Output: Confirmed accident data, error message (if necessary)

[1288] Step 3: Analysis of the accident

[1289] The server retrieves the stored accident data from the database and analyzes the text data using a natural language processing model (e.g., OpenAI GPT-4). The model extracts causes and effects from the text data and identifies relevant keywords. It also analyzes video data using image recognition algorithms such as the YOLO series to detect anomalies.

[1290] Input: Confirmed accident data

[1291] Output: Accident cause analysis results, related keywords, anomaly detection results

[1292] Step 4: Automatic generation of learning content and test questions

[1293] Based on the analysis results, the server automatically generates learning content and test questions using a generative AI model (e.g., GPT-4). The learning content includes detailed explanations of the causes of accidents and countermeasures, as well as diagrams and checklists, while the test questions include multiple-choice and fill-in-the-blank questions.

[1294] Input: Accident cause analysis results, related keywords, anomaly detection results

[1295] Output: Learning content, test questions

[1296] Step 5: Automated Delivery

[1297] The server automatically distributes the generated learning content and test questions based on the associated user list via the company's internal messaging system, email, factory kiosks, and smartphone apps.

[1298] Input: learning content, test questions

[1299] Output: Delivery notification (internal messaging, email, app notification)

[1300] Step 6: Training and testing

[1301] The user receives a notification of delivery, browses the learning content on their device, studies, and then answers the test questions. The test answers are sent to the server in real time.

[1302] Input: Delivery notification

[1303] Output: Test answer

[1304] Step 7: Collect emotion data

[1305] During training and testing, the device uses an emotion engine (e.g., Affectiva) to collect emotion data from the user's facial expressions and voice, which is then transmitted to the server in real time.

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

[1307] Output: Emotion data

[1308] Step 8: Evaluate test results and sentiment data

[1309] The server aggregates test answers and emotional data to evaluate the user's level of understanding and emotional state, and based on the evaluation results, it readjusts the learning content or provides instructions for additional learning.

[1310] Input: Test answers, emotion data

[1311] Output: Comprehension assessment results, readjustment instructions, additional study instructions

[1312] Step 9: Follow up

[1313] Based on the evaluation results, the server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action to be taken even if the user's understanding is insufficient.

[1314] Input: Comprehension assessment results, readjustment instructions, additional study instructions

[1315] Output: Follow-up notification (re-learning, re-test instructions)

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

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

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

[1319] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1333] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in large development organizations. Below, we will explain the program processing of this system in natural language, and provide concrete examples.

[1334] System Overview

[1335] This system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users, thereby quickly sharing knowledge for accident prevention. The entire system is mainly composed of a server, terminals, and users.

[1336] Accident data collection

[1337] 1. When an accident occurs, the user enters the accident data into a form for entering details of the accident. The accident data includes the date and time of the accident, the extent of the impact, the cause, specific details of the problem, and countermeasures.

[1338] 2. The terminal checks the format of the entered accident data and performs error checking to notify of input errors if necessary.

[1339] 3. The server stores the correctly formatted accident data in a database for later analysis.

[1340] Analysis of the accident

[1341] 1. The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, thereby extracting the causes of the accident and countermeasures.

[1342] 2. The server uses a clustering algorithm to group accident data with similar causes and countermeasures and organize the analysis results.

[1343] Automatic generation of learning content and test questions

[1344] 1. The server uses a generative AI model to automatically generate learning content from the analysis results, including text, diagrams, and checklists, with detailed explanations of specific examples and countermeasures.

[1345] 2. The server then automatically generates test questions based on the generated learning content to test comprehension, including multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[1346] Automatic sharing and notifications

[1347] 1. The server automatically distributes the generated learning content and test questions to a list of relevant users via an internal messaging system or email.

[1348] 2. The device sends a notification to the user so that they can access the delivered learning content and test questions.

[1349] Study and test

[1350] 1. Users receive a notification and can view the learning content on their device. The learning content can be easily accessed through a web browser or dedicated application.

[1351] 2. After studying, the user answers test questions on their device. The test results are sent to the server in real time.

[1352] Test result evaluation and follow-up

[1353] 1. The server aggregates the received test results and evaluates each user's level of understanding. The results are displayed on a dashboard so that administrators can check their progress.

[1354] 2. The server will then provide instructions for follow-up study as needed, and may automatically notify students of retests or additional assignments.

[1355] Specific examples

[1356] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. Next, the server uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and takes the test, and their level of understanding is evaluated. Based on the results of the evaluation, the server notifies them of additional learning as necessary.

[1357] This will enable efficient sharing of knowledge and effectively prevent accidents from occurring again.

[1358] The processing flow will be explained below.

[1359] Step 1:

[1360] When an accident occurs, users enter a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The form includes detailed information such as the date and time of the accident, the names of the affected systems and modules, specific details of the problem, and the time until recovery.

[1361] Step 2:

[1362] The terminal checks the entered accident data to see if there are any errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[1363] Step 3:

[1364] The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[1365] Step 4:

[1366] The server runs a natural language processing (NLP) model to analyze the stored accident data, extracting causes and effects from the text data and identifying relevant keywords.

[1367] Step 5:

[1368] Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of accidents, which allows accidents with similar causes and countermeasures to be grouped together and classified.

[1369] Step 6:

[1370] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures, including text, diagrams, and checklists related to the causes of accidents and countermeasures.

[1371] Step 7:

[1372] The server automatically generates test questions based on the learning content, including multiple choice, word fill-in-the-blank, and question-and-answer formats, that match the generated content.

[1373] Step 8:

[1374] The server automatically distributes the generated learning content and test questions to relevant users, including departments affected by the incident and members of related teams.

[1375] Step 9:

[1376] The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[1377] Step 10:

[1378] Users receive notifications and can view the learning content through a web interface or dedicated application on their device. The learning content is easily accessible and intuitive to use.

[1379] Step 11:

[1380] After studying, users answer test questions on their devices, and the answers are sent to the server in real time.

[1381] Step 12:

[1382] The server aggregates the received test results and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard and can be checked by an administrator.

[1383] Step 13:

[1384] The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even if the user's understanding is insufficient.

[1385] Example 1

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

[1387] When an accident occurs in a large development organization, it is necessary to quickly and effectively share the cause and countermeasures. However, with conventional methods, collecting and analyzing accident data takes time, which often delays the sharing of knowledge. In addition, manually creating learning content and test questions requires a great deal of effort, resulting in a decrease in the effectiveness of education. A system is needed to solve these issues and efficiently prevent accidents and share knowledge.

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

[1389] In this invention, the server includes means for collecting accident data, means for checking the format of the collected accident data and notifying of input errors, means for analyzing the accident data to extract causes of the accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to relevant users, means for users to study and test, means for collecting and evaluating user test results, and means for instructing additional follow-up study based on the evaluation results. This enables the entire process from collecting accident data to automatically generating, distributing, and evaluating learning content and test questions to be carried out efficiently.

[1390] "Accident data" is data collected when an accident occurs, including information such as the date and time of the accident, the extent of the impact, the cause, the specific details of the problem, and countermeasures.

[1391] The "means of collection" refers to the means by which accident data is input by users and then imported into the system.

[1392] The "means for checking the format and notifying of input errors" refers to a means for checking whether the values ​​in each field of the collected accident data are in the appropriate format, and for prompting the user to re-enter the data if there is an error.

[1393] "Means of analyzing and extracting the causes of accidents and countermeasures" refers to analyzing collected accident data using natural language processing models, etc., and extracting the causes of accidents and countermeasures.

[1394] "Means for automatically generating learning content" refers to a means for automatically generating content (text, illustrations, checklists, etc.) for users to study based on the analysis results using a generative AI model.

[1395] "Means for automatically generating test questions to test comprehension" refers to a means for automatically generating test questions (multiple choice questions, fill-in-the-blank questions, question-and-answer questions, etc.) to evaluate a user's level of comprehension based on the generated learning content.

[1396] The "means for automatically distributing automatically generated learning content and test questions to relevant users" refers to a means for automatically distributing the generated learning content and test questions to relevant users.

[1397] "Means for learning and testing" refers to the means by which a user can view learning content and answer test questions.

[1398] The "means for collecting and evaluating test results" refers to a means for aggregating test results sent by users and evaluating the level of understanding of each user.

[1399] The "means for instructing additional follow-up study" refers to a means for instructing the user on necessary additional study based on the evaluation of the test results, and for notifying the user of retests or additional assignments.

[1400] This invention is a system for efficiently preventing accidents and sharing knowledge in large development organizations. This system collects and analyzes accident data, automatically generates learning content and test questions based on the data, and distributes them to users, thereby quickly sharing knowledge for preventing accidents. The entire system is mainly composed of a server, terminals, and users.

[1401] An embodiment of the system will now be described in detail.

[1402] First, when an accident occurs, the user accesses a dedicated form and enters the accident data (date and time of occurrence, extent of impact, cause, specific details of the failure, countermeasures, etc.). For example, this can be done using a web browser. After the user has completed the input, they press the send button, which sends the data to the server.

[1403] The terminal receives this data and performs a format check. For example, it checks whether the date and time information is in the "YYYY-MM-DD" format. If there is an error in the input, it displays an error message to the user and prompts them to re-enter the information.

[1404] The server stores the correct formatted accident data sent from the device in a database (for example, MySQL) for later analysis.

[1405] The server retrieves accident data from the database and analyzes the text data using a natural language processing (NLP) model (e.g., BERT), thereby extracting the causes of the accident and countermeasures.

[1406] The server then uses a clustering algorithm (e.g., K-means) to group incident data with the same causes and countermeasures, making it easier to identify similar patterns.

[1407] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content from the analysis results. For example, it generates learning materials such as best practices and checklists for the extracted "lack of review." The server then automatically generates test questions (multiple choice questions, fill-in-the-blank questions, question-and-answer questions, etc.) to test comprehension based on the generated learning content.

[1408] The server automatically distributes these learning contents and test questions to relevant users, for example, via an internal messaging system (e.g., Slack) or email.

[1409] The device notifies the user when new learning content and test questions have been distributed. The user receives the notification and accesses the learning content from their device (PC or smartphone). The learning content can be easily accessed through a web browser or dedicated application.

[1410] Users study the content and answer test questions. The test results are sent in real time to the server, which then aggregates them and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard, allowing administrators to monitor progress.

[1411] Based on the evaluation results, the server automatically recommends additional follow-up learning, and will also notify students of retests or additional assignments as necessary.

[1412] As a specific example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident. The device performs a format check and, if no errors are found, sends the data to the server. The server uses a natural language processing model to identify "insufficient reviews" as the cause and "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the devices of the relevant developers, and the users study and take the test, with their level of understanding being evaluated by the server. Depending on the evaluation results, the server notifies them of additional learning as necessary.

[1413] An example of a prompt is, "Please explain the cause and solution of a system outage that occurred in a certain development team. Also, please generate appropriate learning content and test questions based on that." This system will enable efficient knowledge sharing and the prevention of accident recurrence.

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

[1415] Step 1:

[1416] When an accident occurs, the user accesses a dedicated form and enters the accident data (date and time of occurrence, extent of impact, cause, specific details of the problem, countermeasures, etc.). After completing the input, the user clicks the send button.

[1417] Input: Accident data (occurrence date and time, extent of impact, cause, specific details of the failure, countermeasures)

[1418] Output: Accident data entered into the form

[1419] Step 2:

[1420] The terminal receives the transmitted accident data and performs format checks, for example, checking that the date field is in "YYYY-MM-DD" format, and if there is an error, it displays an error message to the user and asks them to re-enter the data.

[1421] Input: Accident data submitted via the form

[1422] Output: Correctly formatted incident data or an error message

[1423] Step 3:

[1424] The server stores the correct formatted accident data sent from the device in a database (e.g., MySQL).

[1425] Input: Accident data that passes format check

[1426] Output: Accident data stored in a database

[1427] Step 4:

[1428] The server retrieves accident data from the database, analyzes the text data using a natural language processing (NLP) model (e.g., BERT), and extracts the causes of the accident and countermeasures.

[1429] Input: Accident data retrieved from the database

[1430] Output: Extracted causes of accidents and countermeasures

[1431] Step 5:

[1432] The server uses a clustering algorithm (e.g., K-means) to group similar data based on the analyzed causes and countermeasures of the accident.

[1433] Input: Extracted cause and countermeasure data

[1434] Output: Clustered accident data

[1435] Step 6:

[1436] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content from the clustering results, such as best practices for review gaps and checklists to prevent similar incidents from occurring.

[1437] Input: Clustering results

[1438] Output: Auto-generated learning content

[1439] Step 7:

[1440] The server automatically generates test questions to assess comprehension based on the generated learning content, including multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[1441] Input: Learning content

[1442] Output: Auto-generated test questions

[1443] Step 8:

[1444] The server automatically distributes the generated learning content and test questions to relevant users, for example, via an internal messaging system (e.g., Slack) or email.

[1445] Input: Learning content and test questions

[1446] Output: Delivery notification to user

[1447] Step 9:

[1448] The device will notify the user when new learning content and test questions are available via pop-ups, push notifications, emails, etc.

[1449] Input: Delivery notification from the server

[1450] Output: A message to inform the user

[1451] Step 10:

[1452] Users receive a notification and can access the learning content from their device (PC or smartphone) via a web browser or dedicated application.

[1453] Input: Delivered learning content

[1454] Output: User learning activity

[1455] Step 11:

[1456] After studying, users answer test questions using their devices, and the test results are sent to the server in real time.

[1457] Input: Answer to test question

[1458] Output: Test results sent in real time

[1459] Step 12:

[1460] The server aggregates the received test results and evaluates each user's level of understanding. The evaluation results are displayed on a dashboard so that administrators can check their progress.

[1461] Input: Test result data

[1462] Output: Aggregated evaluation results and dashboard display

[1463] Step 13:

[1464] Based on the evaluation results, the server automatically recommends additional follow-up learning as needed, and also notifies students of retests and additional assignments.

[1465] Input: Aggregated evaluation results

[1466] Output: Notifications for follow-up study and retesting

[1467] (Application example 1)

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

[1469] Accidents in factories threaten the safety of workers and reduce productivity. Conventional systems tend to be slow to share knowledge to prevent accidents, and preventive measures are not quickly implemented. For this reason, there is a need for a system that can quickly and efficiently collect and analyze accident data, automatically generate appropriate learning content and test questions based on that data, and quickly share them with workers and robots.

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

[1471] In this invention, the server includes means for collecting accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the automatically generated learning content and test questions to related workers and robots, means for workers to study and test, and means for collecting and evaluating test results. This allows knowledge on accident prevention to be shared quickly and efficiently, making it possible to prevent accidents from recurring at factory sites.

[1472] "Accident data" refers to detailed information about accidents that occur within a factory, including the date and time of the accident, the extent of the impact, the cause, the specific details of the problem, and countermeasures.

[1473] A "natural language processing model" refers to algorithms and techniques that allow computers to understand, analyze, and generate human language, providing a means of extracting meaning and context from text.

[1474] A "generative AI model" is an algorithm that uses machine learning to automatically generate new content and data, generating text, images, audio, etc. based on given input.

[1475] "Learning content" refers to learning materials for acquiring specific knowledge or skills, and includes text, illustrations, checklists, etc.

[1476] "Test questions" are questions or tasks used to assess a user's understanding of the learning content, and may include multiple choice questions, fill-in-the-blank questions, and question-and-answer questions.

[1477] A "robot" is a mechanical device that automatically performs specific tasks or operations in a factory, helping to prevent accidents and share knowledge.

[1478] The "Factory Robot Support System" is an integrated system for collecting and analyzing accident data, generating and distributing learning content, generating test questions, and providing these to workers and robots.

[1479] As an embodiment of the present invention, the following factory robot support system is provided. The entire system is mainly composed of a server, terminals, and users (workers and robots). How each component of the system interacts and functions will be explained below.

[1480] System Overview

[1481] This factory robot support system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users and robots, thereby quickly sharing knowledge to prevent accidents.

[1482] Hardware and Software

[1483] Hardware

[1484] Factory robot: A device with an interface that allows workers to easily input accident data and share knowledge about accident prevention.

[1485] Server: Provides infrastructure for database management, natural language processing analysis, and generative AI model operation.

[1486] software

[1487] Natural language processing (NLP) engine: Used to analyze text data, and specific technologies include models such as BERT and GPT-3.

[1488] Clustering algorithms: Used to group accident data with similar causes and countermeasures, specific techniques include k-means.

[1489] Generative AI models: Used to automatically generate learning content and test questions; specific technologies include OpenAI's GPT-3.

[1490] Program processing explanation

[1491] 1. Entering accident data and checking for errors

[1492] When an accident occurs, the user inputs details of the accident into a terminal built into the factory robot, which then checks the input data for incomplete data or input errors.

[1493] 2. Accident data storage

[1494] Correctly formatted accident data is sent to a server and stored in a database for later analysis.

[1495] 3. Analysis of the accident

[1496] The server retrieves the accident data from the database, performs text analysis using natural language processing techniques (e.g., BERT or GPT-3), and then groups the accident data using a clustering algorithm (e.g., k-means).

[1497] 4. Automatic generation of learning content and test questions

[1498] Generative AI models (e.g., GPT-3) are used to generate learning content from the analysis results, including text, diagrams, checklists, etc. Test questions are also automatically generated to test comprehension.

[1499] 5. Delivery and Notification

[1500] The generated learning content and test questions are automatically distributed by the server to the relevant workers and robots via the factory messaging system or email, and notifications are sent by the terminals.

[1501] 6. Implementation of learning

[1502] The worker receives a notification and views the learning content on their device. After studying, they take a test, and the test results are sent to the server in real time.

[1503] 7. Evaluation and follow-up of test results

[1504] The server aggregates the received test results and evaluates each worker's level of understanding. The results are displayed on a dashboard, allowing managers to check progress and, if necessary, instruct additional follow-up learning.

[1505] Specific examples

[1506] For example, if a collision occurs while operating a forklift in a factory, the worker uses the robot's interface to input details of the accident. The server analyzes this data, identifies "misoperation of the forklift" as the cause, and extracts "improvement of operating techniques" as the countermeasure. Next, it uses a generative AI model to generate learning content on "safe forklift operation methods" and test questions on "risks caused by operating errors." These content and test questions are then distributed to the relevant workers and robots.

[1507] Example prompt for a generative AI model:

[1508] "Please create learning content that instructs students on how to improve their driving techniques regarding collision accidents that occurred due to forklift driving errors, and create test questions to measure their understanding."

[1509] This will enable accident prevention knowledge to be shared effectively within the factory, preventing recurrence.

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

[1511] Step 1: Enter accident data and check for errors

[1512] The user inputs details of the accident into a terminal built into the factory robot. The terminal receives the input accident data (date and time of occurrence, extent of impact, cause, specific details of the problem, and countermeasures) and checks for incomplete data or input errors. For example, if the date and time are inaccurate, a warning is displayed, prompting correction.

[1513] Input: Accident details

[1514] Output: Well-formatted incident data or error messages

[1515] Step 2: Save the incident data

[1516] Accident data in the correct format is sent from the device to the server, which then stores the received data in a database for later analysis.

[1517] Input: Correctly formatted accident data

[1518] Output: Accident data stored in a database

[1519] Step 3: Analysis of the accident

[1520] The server retrieves accident data from the database, performs text analysis using natural language processing techniques (e.g., BERT or GPT-3) to extract accident causes and countermeasures, and then uses a clustering algorithm (e.g., k-means) to group accident data with similar causes and countermeasures.

[1521] Input: Accident data retrieved from the database

[1522] Output: Analysis results (causes of accidents and countermeasures), grouped accident data

[1523] Step 4: Automatic generation of learning content and test questions

[1524] The server uses a generative AI model (e.g., GPT-3) to automatically generate learning content based on the causes and countermeasures of accidents. This content includes text, diagrams, checklists, etc. At the same time, test questions are automatically generated to test comprehension.

[1525] Input: Analysis results (cause of accident and countermeasures)

[1526] Output: Auto-generated learning content, test questions

[1527] Step 5: Delivery and Notification

[1528] The server automatically distributes the generated learning content and test questions to the relevant workers and robots via the factory's messaging system or email, and the terminals send notifications. Specifically, each worker receives a notification message containing a link to the content.

[1529] Input: learning content, test questions

[1530] Output: Auto-distributed content and notification messages

[1531] Step 6: Learning

[1532] The user receives a notification and views the learning content on their device. After viewing the learning content, the worker answers the test questions on their device. The test results are sent to the server in real time.

[1533] Input: learning content, test questions

[1534] Output: Answered test results (sent in real time)

[1535] Step 7: Evaluate and follow up on test results

[1536] The server aggregates the received test results and evaluates each user's level of understanding. The results are displayed on a dashboard so administrators can check progress and automatically recommend additional follow-up learning if necessary.

[1537] Input: Test result

[1538] Output: Assessment results, dashboard display, and instructions for further follow-up

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

[1540] This invention is a system for preventing accidents and improving the efficiency of knowledge sharing in large development organizations, and by combining it with user emotion recognition, it improves the effectiveness of the learning process. Below, we will explain the program processing of this system in natural language, and provide concrete examples.

[1541] System Overview

[1542] This system collects and analyzes accident data, automatically generates learning content and test questions based on that data, and distributes them to users, quickly sharing knowledge for accident prevention. It also uses an emotion engine to recognize user emotions and improve the effectiveness of the learning content and tests. The entire system is primarily composed of a server, terminals, and users.

[1543] Accident data collection

[1544] 1. When an accident occurs, the user enters a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The accident data includes detailed information such as the date and time of the accident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery.

[1545] 2. The terminal checks the entered accident data and checks for errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[1546] 3. The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[1547] Analysis of the accident

[1548] 1. The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, which extracts causes and effects from the text data and identifies relevant keywords.

[1549] 2. Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of the accidents, thereby grouping accident data with similar causes and countermeasures and classifying the accidents.

[1550] Automatic generation of learning content and test questions

[1551] 1. The server uses the generative AI model to automatically generate learning content based on the extracted causes and countermeasures. The generated content includes text, diagrams, checklists, etc. related to the causes of accidents and countermeasures.

[1552] 2. The server automatically generates test questions based on the learning content to test comprehension, including multiple choice questions, word fill-in-the-blank questions, and question-and-answer questions, and these questions match the generated content.

[1553] Automatic sharing and notifications

[1554] 1. The server automatically distributes the generated learning content and test questions to the relevant user list via the company's internal messaging system or email.

[1555] 2. The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[1556] Use of emotion engine

[1557] 1. The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing. For example, changes in facial expressions when viewing learning content, or voice tones when answering test questions.

[1558] 2. The server analyzes the user's emotional data recognized by the emotion engine and adjusts the difficulty and content of the learning content accordingly. For example, if the user is confused, it will provide additional explanations.

[1559] 3. The server reflects the emotional data in the evaluation of the test results, enabling a more accurate assessment of the user's comprehension level, thereby enabling a comprehensive assessment of the user's actual comprehension level and emotional state.

[1560] Study and test

[1561] 1. Users receive a notification and can view the learning content on their device. The learning content can be easily accessed through a web browser or dedicated application.

[1562] 2. After studying, the user answers test questions on the device, and the test answers are sent to the server in real time.

[1563] Test result evaluation and follow-up

[1564] 1. The server aggregates the received test results and evaluates each user's level of understanding and emotional data. The evaluation results are displayed on a dashboard and can be confirmed by an administrator.

[1565] 2. The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even when the user's understanding is insufficient.

[1566] Specific examples

[1567] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning and testing, the device uses an emotion engine to collect user emotional data, which the server analyzes and adjusts the learning content as needed. Based on the evaluation results, the server notifies the user of additional learning as needed.

[1568] This enables efficient knowledge sharing, effectively prevents accidents from recurring, and provides a learning experience that takes users' emotions into consideration.

[1569] The processing flow will be explained below.

[1570] Step 1:

[1571] When an accident occurs, users enter a summary of the accident, its cause, impact, and countermeasures into a dedicated form on the system. The form includes detailed information such as the date and time of the accident, the names of the affected systems and modules, specific details of the problem, and the time until recovery.

[1572] Step 2:

[1573] The terminal checks the entered accident data to see if there are any errors. For example, it verifies whether required fields have been filled in and whether the data format is correct, and if there is a problem, it notifies the user with an error message.

[1574] Step 3:

[1575] The server receives the properly formatted accident data and stores it in a database that contains information such as the accident report identifier, the date and time of the incident, the person who submitted it, and the department in charge.

[1576] Step 4:

[1577] The server retrieves the collected accident data from the database and analyzes the text data using a natural language processing (NLP) model, which extracts causes and effects from the text data and identifies relevant keywords.

[1578] Step 5:

[1579] Based on the analysis results, the server uses a clustering algorithm to extract the causes and countermeasures of accidents, thereby grouping accident data with similar causes and countermeasures and classifying the accidents.

[1580] Step 6:

[1581] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures, including text, diagrams, and checklists related to the causes of accidents and countermeasures.

[1582] Step 7:

[1583] The server automatically generates test questions based on the learning content, including multiple choice, word fill-in-the-blank, and question-and-answer formats, that match the generated content.

[1584] Step 8:

[1585] The server automatically distributes the generated learning content and test questions to the relevant user list via the company's internal messaging system or email.

[1586] Step 9:

[1587] The device notifies the user of the delivered learning content and test questions via internal messaging, email, or a dedicated application.

[1588] Step 10:

[1589] The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing, such as changes in facial expressions when viewing learning content or voice tones when answering test questions.

[1590] Step 11:

[1591] The server analyzes the user's emotional data recognized by the emotion engine and adjusts the difficulty and content of the learning content accordingly. For example, if the user is confused, it will provide additional explanations.

[1592] Step 12:

[1593] Users receive notifications and can view the learning content on their devices, which can be easily accessed through a web browser or dedicated application.

[1594] Step 13:

[1595] After studying, users answer test questions on their devices, and the answers are sent to the server in real time.

[1596] Step 14:

[1597] The server aggregates the received test results and evaluates each user's level of understanding and emotional data. The evaluation results are displayed on a dashboard and can be checked by an administrator.

[1598] Step 15:

[1599] The server automatically sends instructions for additional follow-up study or retesting as needed, allowing for prompt action even if the user's understanding is insufficient.

[1600] Examples:

[1601] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server analyzes this using a natural language processing model, identifies "insufficient reviews" as the cause, and extracts "strengthening reviews" as the countermeasure. The server then uses a generative AI model to automatically generate learning content on "review methods and best practices" and test questions on "risks caused by insufficient reviews." These content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning and testing, the device uses an emotion engine to collect user emotional data, which the server analyzes and adjusts the learning content as needed. Based on the evaluation results, the server notifies the user of additional learning as needed.

[1602] Example 2

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

[1604] Large development organizations are seeking systems that can prevent accidents and share knowledge quickly and efficiently. Furthermore, existing learning systems do not take users' emotions into account, making effective learning difficult and preventing improvements in understanding. The present invention aims to solve these problems and provide an effective learning system that takes users' emotions into account.

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

[1606] In this invention, the server includes means for collecting accident data, means for verifying the collected accident data, means for analyzing the accident data to extract causes of accidents and countermeasures, means for analyzing the collected accident data using a natural language processing model, means for automatically generating learning content based on the extracted causes and countermeasures, means for automatically generating learning content using a generative AI model, means for automatically generating test questions to test comprehension based on the learning content, means for automatically distributing the generated learning content and test questions to relevant users, means for recognizing user emotions using an emotion engine, means for adjusting the learning content based on the recognized emotion data, means for users to study and test, and means for collecting and evaluating user test results and emotion data. This enables the prevention of accident recurrence, the rapid sharing of knowledge, and effective learning that takes user emotions into consideration.

[1607] "Accident data" refers to detailed information about an accident that has occurred, such as an overview, cause, impact, and countermeasures, that is entered into the system by the user.

[1608] "Means of collection" refers to the function of providing a dedicated form or interface for users to input accident data and importing that data into the system.

[1609] "Means of verification" refers to functions that check whether collected accident data has been entered correctly, whether required fields have been filled in, and whether the data format has been confirmed.

[1610] "Means of analysis" refers to the function of analyzing collected accident data using natural language processing (NLP) models, etc., to extract the causes of accidents and countermeasures.

[1611] A "natural language processing model" refers to algorithms and technologies for analyzing text data, understanding its meaning, and extracting important information.

[1612] "Means of extraction" refers to the function of deriving the cause of an accident and countermeasures from the analyzed data.

[1613] A "generative AI model" refers to artificial intelligence technology that automatically generates learning content and test questions based on input data.

[1614] "Learning content" refers to educational materials such as texts, charts, and checklists that contain information about the causes of accidents and countermeasures.

[1615] "Means for automatic generation" refers to the function of automatically creating learning content and test questions based on collected and analyzed data.

[1616] "Test questions" are a set of questions designed to test a user's level of understanding based on the learning content, and include multiple choice questions and fill-in-the-blank questions.

[1617] "Means for automatic distribution" refers to the function of automatically sending generated learning content and test questions to relevant users.

[1618] An "emotion engine" refers to the technology and algorithms used to analyze a user's facial expressions and voice to recognize their emotions.

[1619] "Emotional Data" refers to data regarding a user's emotional state collected using an emotion engine.

[1620] "Means of adjustment" refers to the function of appropriately changing the learning content, difficulty of test questions, etc. based on collected emotional data.

[1621] "User" means any individual or member of an organization who uses the System.

[1622] "Means of evaluation" refers to the function of compiling users' test results and emotional data to comprehensively assess their level of understanding.

[1623] The "system" refers to a comprehensive set of technologies and devices that combine the aforementioned measures to prevent accidents from recurring, share knowledge, and provide an effective learning experience.

[1624] This invention is a system that improves the efficiency of accident prevention and knowledge sharing in large development organizations, and further improves the effectiveness of the learning process by combining it with user emotion recognition. This system is mainly composed of a server, terminals, and users.

[1625] Accident data collection

[1626] The user enters details of the accident into a dedicated form in the system. The data to be entered includes the date and time of the accident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery. The terminal verifies the entered data, checking whether required fields have been filled in and whether the data format is correct. If there are any errors, an error message is displayed to the user. The server stores the accident data in a database once it has been confirmed to be in the correct format.

[1627] Analysis of the accident

[1628] The server retrieves accident data from the database and analyzes the text data using a natural language processing (NLP) model. The model extracts causes and effects from accident reports and identifies relevant keywords. It then uses a clustering algorithm to classify similar accidents and extract causes and countermeasures.

[1629] Automatic generation of learning content and test questions

[1630] The server uses a generative AI model to automatically generate learning content from the analysis results. The generated content includes text, diagrams, checklists, and other information related to the causes of accidents and countermeasures. Furthermore, test questions to test comprehension are automatically created based on the learning content. Test questions include multiple choice questions, word fill-in-the-blank questions, and question-and-answer format questions.

[1631] Automatic sharing and notifications

[1632] The server automatically distributes the generated learning content and test questions to relevant users via an internal messaging system or email. The device then notifies the user of the distributed content and test questions.

[1633] Use of emotion engine

[1634] The device uses an emotion engine to recognize the user's facial expressions and voice during learning and testing. For example, it monitors changes in facial expressions and tone of voice. The server analyzes the collected emotion data and adjusts the difficulty and content of the learning content accordingly. It can also provide additional explanations to confused users.

[1635] Study and test

[1636] Users receive notifications and can view the learning content on their devices via a web browser or dedicated application. After studying, users answer test questions, and their answers are sent to the server in real time.

[1637] Test result evaluation and follow-up

[1638] The server aggregates the test results and collected emotional data to evaluate each user's level of understanding. The evaluation results are displayed on a dashboard for administrators to review. If necessary, instructions for additional follow-up learning or retesting are automatically sent.

[1639] Specific examples

[1640] For example, if a development team experiences a system outage due to insufficient code reviews, the user enters details of the incident into the system. The server then uses a natural language processing model to identify "insufficient reviews" and recommends "strengthening reviews" as a countermeasure. The server then uses a generative AI model to automatically generate learning content on "best practices for code reviews" and create test questions on "risks caused by insufficient reviews." The content and test questions are distributed to the relevant developer's device, and the user studies and tests. During learning, the device uses an emotion engine to collect user emotion data, and the server sends additional learning instructions based on the analysis results.

[1641] Prompt Sentence Examples

[1642] We recently had an incident in our internal system. Please input the details of this incident, analyze it, and generate appropriate learning content and test questions.

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

[1644] Step 1:

[1645] The user enters incident data into a dedicated form in the system. The input data includes the date and time of the incident, the names of the affected systems and modules, the specific details of the failure, and the time until recovery. This data provides basic information about the incident. When the input data is sent to the form, the terminal receives and temporarily stores the data.

[1646] Step 2:

[1647] The terminal verifies the accident data entered by the user. Specifically, it checks whether all required fields are filled in and whether the date and time format is correct. For example, it checks whether the date and time of the accident was entered in the format "mm / dd / yyyy hh:mm." If an error is detected during this verification step, the terminal displays an error message to the user and prompts them to re-enter the data. If the input is correct, the data passes the format check and is sent to the server.

[1648] Step 3:

[1649] The server receives the accident data that has been confirmed to be in the correct format and stores it in a database. The database stores information such as the identifier of each accident report, the date and time of the incident, the person who made the report, and the department in charge. The input to this step is the accident data sent from the terminal, and the output is the accident data stored in the database.

[1650] Step 4:

[1651] The server extracts accident data from the database and sends it to a natural language processing (NLP) model to analyze the accident details. The input is the acquired text data, and the output is a list of keywords indicating the extracted causes and effects. For example, the keyword "database connection error" is extracted.

[1652] Step 5:

[1653] The server uses a clustering algorithm to classify similar accidents based on the keywords extracted from the NLP model. The input is a list of keywords generated by the NLP model, and the output is a set of clusters of similar accidents. This allows accidents caused by the same reasons to be grouped together.

[1654] Step 6:

[1655] The server uses a generative AI model to automatically generate learning content based on the extracted causes and countermeasures. The input is the clustered accidents, their causes, and countermeasures, and the output is learning content (text, diagrams, checklists, etc.). For example, content containing detailed explanations on "countermeasures for database connection errors" is generated.

[1656] Step 7:

[1657] The server also automatically generates test questions to test comprehension based on the generated learning content. The input is the generated learning content, and the output is multiple-choice questions, word fill-in-the-blank questions, and question-and-answer style test questions. As a specific example, a multiple-choice question such as "What is the cause of the database connection error?" is created.

[1658] Step 8:

[1659] The server distributes the generated learning content and test questions to the relevant users. Notifications are sent via the company's internal messaging system or email. The input is the learning content and test questions, and the output is the notification message. The terminal receives this and displays a pop-up or notification to the user.

[1660] Step 9:

[1661] The device uses an emotion engine to recognize the user's facial expressions and voice during training and testing. The input is video and audio data captured by a camera and microphone, and the output is recognized emotion data. For example, if the user is confused, that emotion data is collected.

[1662] Step 10:

[1663] The server analyzes the emotional data obtained from the emotion engine and automatically adjusts the difficulty level of the learning content and additional explanations. The input is emotional data, and the output is a specific action such as "display a link to additional explanations."

[1664] Step 11:

[1665] The user actually views the learning content that has been notified to them. By accessing it from their device, they can proceed with their learning through a web browser or dedicated application. The input is a request to access the learning content, and the output is the displayed learning content.

[1666] Step 12:

[1667] After studying, users answer test questions on their devices. The answers are sent to the server in real time, and the test is evaluated. The input is the user's answer data, and the output is the test results.

[1668] Step 13:

[1669] The server integrates the received test results and emotional data to evaluate the overall level of understanding. The results are displayed on a dashboard for administrator confirmation. The input is the test results and emotional data, and the output is an evaluation report and dashboard display.

[1670] Step 14:

[1671] The server notifies the user of additional follow-up study or retesting as necessary. The input is the evaluation result, and the o...

Claims

1. a means for collecting accident data; A means of analyzing accident data to extract causes of accidents and countermeasures; A means for automatically generating learning content based on the extracted causes and countermeasures; A means for automatically generating test questions to test comprehension based on the learning content; A means for automatically distributing auto-generated learning content and test questions to relevant users; a means for users to learn and test; a means of collecting and evaluating user test results; A system including:

2. 10. The system of claim 1, further comprising means for analyzing the collected accident data using a natural language processing model.

3. 10. The system of claim 1, further comprising means for automatically generating learning content and test questions using the generative AI model.

Images