System

Abstract

To provide a system.SOLUTION: A system comprises the means of: recognizing feeling of a user through a feeling engine; and determining failure cause and generating a handling method through a generative AI model based on log data outputted by an information processing device at the occurrence of failure and prompting message that is made by combining the past failure correspondence histories and the technical documents. The generating means generates the handling method based on the recognized feeling of the user.SELECTED DRAWING: Figure 1

Description

[Technical field]

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

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

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

[0004] When network equipment breaks down, identifying the cause and proposing appropriate countermeasures requires specialized knowledge and experience. However, there are only a limited number of people with such specialized knowledge and experience, and because there are a wide variety of causes of failures and countermeasures, it is difficult to respond quickly. [Means for solving the problem]

[0005] The present invention provides a system that includes a generative AI that identifies the cause of a fault and proposes countermeasures in natural language using past fault response history, syslogs output by network devices when a fault occurs, and manufacturer manuals as learning data. This system enables quick and appropriate fault response without requiring specialized knowledge or experience. [Brief description of the drawings]

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

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

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

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

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

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

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

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

[0014] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0027] "Example 1"

[0028] One embodiment of the present invention is a system including a generation AI that uses past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data. This system receives as input the syslogs output by network devices when a failure occurs, and identifies the cause of the failure based on the learning data. Furthermore, based on the identified cause of the failure, the system proposes an appropriate countermeasure in natural language.

[0029] "Example 2"

[0030] As a specific example, consider the case where a network switch breaks down. The syslog output by the switch when a failure occurs is input into the generation AI. The generation AI identifies the cause of the failure from the syslog based on the past failure response history and manufacturer manuals used as learning data. For example, if the syslog contains the error message "port error," the generation AI will determine that there is a problem with the port. Then, based on the past failure response history, it will suggest solutions in natural language, such as "restart the port" or "replace the cable."

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

[0032] "Example 1"

[0033] Step 1: Input the syslog output by the network device when a failure occurs into the generation AI.

[0034] Step 2: The generating AI identifies the cause of the failure from the syslog based on past failure response history and manufacturer manuals used as learning data.

[0035] Step 3: Based on the identified cause of the failure, an appropriate countermeasure is suggested in natural language.

[0036] "Example 2"

[0037] Step 1: When a network switch fails, the syslog output by the switch at the time of the failure is input into the generation AI.

[0038] Step 2: The generated AI analyzes the error message (e.g. "porterror") contained in the syslog and determines that there is a problem with the port.

[0039] Step 3: The generative AI suggests solutions in natural language, such as "restart the port" or "replace the cable," based on past fault response history.

[0040] Example 1

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

[0042] When a failure occurs in network equipment, it is necessary to quickly and accurately identify the cause and provide the user with an appropriate solution. However, with conventional systems, it takes time to identify the cause of the failure and propose a solution, which means the user cannot respond quickly. In addition, it is difficult to effectively use past failure response history and manufacturer manuals, which can reduce the efficiency of failure response.

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

[0044] In this invention, the server includes a means for receiving log data transmitted from a network device, a means for analyzing the received log data and extracting an error message, a means for inputting the extracted error message to a generative AI model, a means for the generative AI model to use past failure response history, log data, and a manufacturer manual as learning data to identify the cause of the failure, a means for the generative AI model to generate an appropriate countermeasure in natural language based on the identified cause of the failure, and a means for notifying a user of the generated countermeasure. This makes it possible to quickly and accurately identify the cause of a failure in a network device and provide the user with an appropriate countermeasure.

[0045] A "network device" is a hardware device for conducting data communications, and includes routers, switches, firewalls, etc.

[0046] "Log data" refers to recorded information generated by network devices during operation, and includes error messages and warning messages.

[0047] An "error message" is warning information that is output when a network device detects a failure or abnormality.

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

[0049] "Failure response history" refers to data that records past failures and how they were handled.

[0050] A "manufacturer's manual" is a document that includes operating procedures and troubleshooting guides provided by the manufacturer of network equipment.

[0051] "Natural language" refers to the language used by humans on a daily basis, and is the form of response output by generative AI models.

[0052] "User" means an individual or organization that manages and operates network equipment.

[0053] A "notification" is an action in which the server conveys information to the user, and is carried out via email or the dashboard.

[0054] The present invention is a system for quickly and accurately identifying the cause of a fault in a network device and providing a user with an appropriate solution. A specific embodiment of this system will be described below.

[0055] Hardware and software used

[0056] Hardware: Server (e.g. general-purpose server)

[0057] Software: Generative AI models (e.g., general generative AI models), syslog analysis tools (e.g., general log analysis tools)

[0058] System Configuration

[0059] 1. The server receives log data sent from the network device. Specifically, the server functions as a syslog server and receives log data from the network device on port 514.

[0060] 2. The server analyzes the received log data and extracts error messages. Specifically, the server uses a log analysis tool to extract error messages and warning messages from the log data.

[0061] 3. The server prepares the extracted error message as data to be input to the generative AI model. Specifically, it formats the error message in text format and launches the generative AI model.

[0062] 4. The server inputs the error message into the generative AI model to identify the cause of the failure. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data, and estimates the cause of the failure based on the error message.

[0063] 5. The server uses a generative AI model to generate an appropriate solution based on the identified cause of the failure. The generative AI model proposes the solution in natural language.

[0064] 6. The server notifies the user of the generated solution. Specifically, the server provides the solution to the user via email or dashboard.

[0065] Examples

[0066] 1. The network device outputs log data containing the error message "Interface down."

[0067] 2. The server receives this log data and extracts the error message "Interface down."

[0068] 3. The server inputs the error message "Interface down" into the generative AI model.

[0069] 4. The generative AI model refers to past fault response history and manufacturer manuals to identify "broken cable" or "port failure" as the cause of "Interface down."

[0070] 5. The generative AI model then uses natural language to suggest solutions such as "check the cable and replace if necessary" or "restart the port."

[0071] 6. The server notifies the user of this solution.

[0072] Examples of prompt statements

[0073] "The log data from a network device contains the error message 'Interface down'. What is the cause of this error message and how can I resolve it?"

[0074] In this way, the server realizes a system that identifies the cause of a failure in a network device and provides the user with an appropriate solution.

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

[0076] Step 1:

[0077] The server receives log data sent from the network device. Specifically, the server functions as a syslog server and receives log data from the network device on port 514. The input is the log data from the network device, and the output is the received log data.

[0078] Step 2:

[0079] The server analyzes the received log data and extracts error messages. Specifically, it uses a log analysis tool to filter error messages and warning messages from the log data. The input is the received log data and the output is the extracted error messages.

[0080] Step 3:

[0081] The server prepares the extracted error message as data to be input to the generative AI model. Specifically, it formats the error message in text format and launches the generative AI model. The input is the extracted error message, and the output is the text data to be input to the generative AI model.

[0082] Step 4:

[0083] The server inputs error messages into the generative AI model and identifies the cause of the failure. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data, and estimates the cause of the failure based on the error message. The input is the text data input into the generative AI model, and the output is the identified cause of the failure.

[0084] Step 5:

[0085] The server uses a generative AI model to generate an appropriate solution based on the identified cause of the failure. The generative AI model proposes a solution in natural language. The input is the identified cause of the failure, and the output is the generated solution.

[0086] Step 6:

[0087] The server notifies the user of the generated solution. Specifically, the solution is provided to the user via email or a dashboard. The input is the generated solution, and the output is the solution notified to the user.

[0088] (Application example 1)

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

[0090] Robots operating in factories need to be diagnosed and repaired quickly and accurately when they break down. However, with conventional systems, it was difficult to identify the cause of the failure or propose an appropriate solution, and repairs often took a long time. There was also the problem that a technician with specialized knowledge was always needed, which increased costs. To solve these issues, a system was needed that could quickly identify the cause of the failure and automatically propose an appropriate solution.

[0091] The identification process by the identification processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means. In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslog output by a network device when a failure occurs, and manufacturer manuals as learning data, a means for diagnosing a failure and providing repair support for a robot operating in a factory, a means for analyzing the syslog output by a robot when a failure occurs and identifying the cause of the failure, and a means for proposing an appropriate countermeasure in natural language based on the identified cause of the failure. This makes it possible to quickly identify the cause of the failure and automatically propose an appropriate countermeasure.

[0092] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[0093] The "syslog output by a network device when a failure occurs" is log data that is generated when a network device fails, and includes detailed information about the failure.

[0094] "Manufacturer's Manual" means an instruction manual or technical documentation provided by a product manufacturer that includes information on how to use the product and troubleshooting.

[0095] "Generative AI" is artificial intelligence that generates new information based on learning data, identifying the cause of failures and proposing countermeasures.

[0096] A "factory robot" is an automated machine designed to perform tasks in a factory.

[0097] "Fault diagnosis" is the analytical process for determining the cause of a fault.

[0098] "Repair assistance" refers to the provision of information and assistance to assist in the repair of broken equipment.

[0099] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[0100] "Analysis" is the process of examining data in detail to understand its meaning and structure.

[0101] "Solutions" are specific actions or steps to be taken in response to an identified problem.

[0102] In order to implement the present invention, the following system configuration and program are required.

[0103] The server contains a generative AI model that uses past fault response history, syslogs output by network devices when a fault occurs, and manufacturer manuals as learning data. This generative AI model analyzes the syslogs output by the robot when a fault occurs and identifies the cause of the fault. It also proposes appropriate countermeasures in natural language based on the identified cause of the fault.

[0104] Specifically, the server performs the following process.

[0105] 1. Data collection and analysis:

[0106] The server receives syslog data sent from robots operating in the factory. The received syslog data is parsed using the syslog_parser module. This analysis extracts detailed information about the failure.

[0107] 2. Identifying the cause of the failure:

[0108] The analyzed data is input to the generative AI model, which has learned from past fault response history and manufacturer manuals, and identifies the cause of the fault based on this. The ai_model module is used for this identification.

[0109] 3. Suggested solutions:

[0110] Based on the identified fault causes, the generative AI model generates appropriate countermeasures, which are generated using the ai_model module. The generated countermeasures are then converted into natural language using the natural_language_processor module.

[0111] 4. Notice to Users:

[0112] The solution converted into natural language is notified to the user, so that the user can quickly take the appropriate solution.

[0113] As a concrete example, by inputting the following prompt sentence into the generative AI model, the cause of the failure and how to deal with it can be identified.

[0114] Prompt text: "2023-10-01 12:00:00 ERROR: Motor failure in section A"

[0115] Using this prompt as input, the generative AI model produces the following output:

[0116] Output: "A motor failure has occurred in section A. Please attempt to restart the motor based on past failure history and manufacturer manual. If restarting is unsuccessful, the motor will need to be replaced."

[0117] In this way, the server can quickly identify the cause of a failure and automatically suggest appropriate countermeasures, which will efficiently diagnose failures and provide repair support for robots operating in factories.

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

[0119] Step 1:

[0120] The server receives syslog data sent from robots operating in the factory. The input is the syslog data from the robot, and the output is the received syslog data. This data includes detailed information such as the time when the failure occurred and error messages.

[0121] Step 2:

[0122] The server parses the received syslog data using the syslog_parser module. The input is the received syslog data, and the output is the parsed failure information. This parsing extracts detailed information such as error messages and the location of the failure.

[0123] Step 3:

[0124] The server inputs the analyzed failure information into the generative AI model. The input is the analyzed failure information, and the output is the identified cause of the failure. The generative AI model learns from past failure response history and manufacturer manuals, and identifies the cause of the failure based on this.

[0125] Step 4:

[0126] The server uses a generative AI model to generate appropriate countermeasures based on the identified cause of the failure. The input is the identified cause of the failure, and the output is the generated countermeasure. The countermeasure is generated based on the history of past failure responses and the manufacturer's manual.

[0127] Step 5:

[0128] The server converts the generated action into natural language using the natural_language_processor module. The input is the generated action and the output is the action converted into natural language. This conversion provides the action in a form that is easy for the user to understand.

[0129] Step 6:

[0130] The server notifies the user of the solution converted into natural language. The input is the solution converted into natural language, and the output is a notification to the user. This allows the user to quickly take appropriate measures.

[0131] Example 2

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

[0133] When network equipment fails, there is a need to quickly and accurately identify the cause of the failure and propose appropriate countermeasures. However, with conventional systems, it takes time to identify the cause of the failure and propose countermeasures, and engineers with specialized knowledge are required, making it difficult to respond to failures efficiently.

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

[0135] In this invention, the server includes a means for receiving log data transmitted from a network device, a means for analyzing the log data and extracting an error message, a means for inputting the extracted error message into a generative AI model and identifying the cause of a failure, a means for proposing a countermeasure based on the cause of the failure by the generative AI model, and a means for notifying a user of the proposed countermeasure. This makes it possible to quickly and accurately identify the cause of a failure and propose an appropriate countermeasure.

[0136] A "network device" is a hardware device for data communication, including routers and switches.

[0137] "Log data" refers to recorded information generated by a network device during operation, and includes error messages and event information.

[0138] An "error message" is a message that is output by a network device when it detects an abnormality, and contains information that is useful for identifying the cause of the failure.

[0139] A "generative AI model" is a model that is trained using artificial intelligence technology to perform specific tasks, such as identifying the cause of a failure and proposing countermeasures based on past data and technical documentation.

[0140] The "cause of failure" is a factor that prevents a network device from operating normally, and is identified from error messages and log data.

[0141] A "remedy" is a remedial measure taken to address the identified cause of the failure, such as rebooting the port or replacing the cable.

[0142] "User" means a person or organization that manages and operates network equipment and is the recipient of troubleshooting proposals.

[0143] The present invention is a system for quickly and accurately identifying the cause of a failure when a network device fails and proposing an appropriate countermeasure. A specific embodiment of this system will be described below.

[0144] The server receives log data sent from the network devices. The log data includes the operating status of the network devices and error messages. The server analyzes the received log data and extracts error messages. This analysis includes checking the format of the data and extracting error messages.

[0145] Next, the server inputs the extracted error message into the generative AI model. The generative AI model uses past fault response history and technical documents as learning data and identifies the cause of the fault from the error message. For example, if the error message contains "port error," the generative AI model will determine that there is a problem with the port.

[0146] After the cause of the failure is identified, the server uses a generative AI model to suggest appropriate countermeasures. The suggestions are generated based on past failure response history and technical documentation. For example, countermeasures such as "restart the port" or "replace the cable" are suggested.

[0147] Finally, the server notifies the user of the proposed solution. Possible notification methods include email and display on the dashboard. This allows the user to quickly identify the cause of the failure and implement the appropriate solution.

[0148] To illustrate, consider the following scenario:

[0149] The server receives log data "2023-10-01 12:00:00 port error detected on port 3" from the network device.

[0150] The server analyzes this log data and extracts the error message "port error."

[0151] The server inputs the extracted error messages into a generative AI model to identify the cause of the failure.

[0152] The generative AI model determines that there is a problem with the port and suggests restarting the port or replacing the cable.

[0153] The server will notify the user of the proposal via email.

[0154] Example prompt:

[0155] Syslog data: "2023-10-01 12:00:00 port error detected on port 3"

[0156] Prompt for generative AI model: "Please identify the cause of the failure from this syslog data and suggest appropriate countermeasures."

[0157] In this way, the server can receive log data, analyze it, and use a generative AI model to identify the cause of the failure and notify the user of the appropriate course of action.

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

[0159] Step 1:

[0160] The server receives the log data transmitted from the network device.

[0161] Specifically, the server listens to a network port and receives log data in real time, which is then temporarily stored.

[0162] Input: Log data from network devices

[0163] Output: Temporarily saved log data

[0164] Step 2:

[0165] The server analyzes the received log data and extracts error messages.

[0166] Specifically, the server checks the format of the log data and extracts the part containing the error message. Regular expressions and pattern matching techniques are used for analysis.

[0167] Input: Temporarily saved log data

[0168] Output: Extracted error message

[0169] Step 3:

[0170] The server inputs the extracted error messages into a generative AI model to identify the cause of the failure.

[0171] Specifically, the server inputs the error message as a prompt to the generative AI model, which then identifies the cause of the failure based on past failure response history and technical documentation.

[0172] Input: The extracted error message

[0173] Output: Identified cause of failure

[0174] Step 4:

[0175] The server then suggests countermeasures based on the causes of the failure identified using the generative AI model.

[0176] Specifically, the server generates appropriate countermeasures based on the cause of the failure obtained from the generative AI model. Countermeasures are proposed based on past failure response history and technical documentation.

[0177] Input: Identified cause of failure

[0178] Output: Suggested action to be taken

[0179] Step 5:

[0180] The server will notify the user of the suggested course of action.

[0181] Specifically, the server retrieves the user's contact information and sends the suggestions via email or dashboard.

[0182] Input: Proposed action

[0183] Output:Notification to the user

[0184] In this way, the server can receive log data, analyze it, and use a generative AI model to identify the cause of the failure and notify the user of the appropriate course of action.

[0185] (Application example 2)

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

[0187] When a factory robot breaks down, it is necessary to quickly and accurately identify the cause of the failure and propose an appropriate solution. However, with conventional systems, it takes time to identify the cause of the failure and propose a solution, which prolongs factory downtime. In addition, there is also the issue of the constant need for engineers with specialized knowledge, which is costly.

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

[0189] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, log data output by the network device when a failure occurs, and the manufacturer's manual as learning data, a means for analyzing in real time the log data generated when the factory robot breaks down, a means for proposing a specific countermeasure based on the past failure response history and the manufacturer's manual, and a means for outputting the generated cause of the failure and the countermeasure in natural language. This enables a quick and accurate response when the factory robot breaks down.

[0190] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[0191] The "log data output by a network device when a failure occurs" is data that includes error messages and status information that are generated when a network device fails.

[0192] A "manufacturer's manual" is a document provided by a manufacturer regarding how to use and troubleshoot a device.

[0193] "Generative AI" is artificial intelligence that learns from past data and identifies the cause of failures and generates countermeasures based on new data.

[0194] A "factory robot" is a mechanical device used to perform automated tasks in a factory.

[0195] "Real-time analysis" means analyzing data as soon as it is generated.

[0196] "Providing suggestions in natural language" means presenting solutions in terms that are easy for humans to understand.

[0197] A "cause of failure" is a factor that causes equipment to not operate normally.

[0198] A "measure" is a method for correcting a malfunction and returning the equipment to a normal state.

[0199] The system for carrying out the present invention is for quickly and accurately dealing with the breakdown of a factory robot. A specific embodiment of the system is described below.

[0200] System Configuration

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

[0202] 1. Server: A computer system for running the generative AI model.

[0203] 2. Factory Robot: A mechanical device that performs automated tasks in a factory.

[0204] 3. Network equipment: Equipment for communication between the robot and the server.

[0205] Hardware and Software Used

[0206] Hardware: Factory robots, servers, network equipment

[0207] Software: Python, OpenAI® API

[0208] Data processing and calculation

[0209] Server Processing

[0210] 1. Log data collection: The server collects log data generated when a factory robot breaks down.

[0211] 2. Prompt sentence generation: The server generates prompt sentences to be input into the generative AI model based on the collected log data.

[0212] 3. Analysis by generative AI: The server uses the OpenAI API to input prompt text into the generative AI model to generate the cause of the failure and a solution.

[0213] 4. Output of results: The server outputs the generated cause of the fault and how to deal with it in natural language and presents it to the user.

[0214] Examples

[0215] For example, if a factory robot generates log data containing the error message "port error on port 3," the server inputs the following prompt sentence into the generative AI model:

[0216] Examples of prompt statements

[0217] Please analyze the following log data and suggest the cause of the failure and how to deal with it.

[0218] Log data: 2023-10-01 12:00:00 ERROR: port error on port 3

[0219] Based on this prompt, the generative AI model determines that "there is a problem with port 3" and suggests solutions such as "restarting the port" or "replacing the cable."

[0220] effect

[0221] This system enables a rapid and accurate response when a factory robot breaks down, minimizing factory downtime. It also contributes to cost reduction because engineers with specialized knowledge are not always required.

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

[0223] Step 1:

[0224] The server collects log data that is generated when a factory robot breaks down. The log data includes error messages and status information. This log data is input. The server receives the log data via the network and stores it in a database.

[0225] Step 2:

[0226] The server generates a prompt sentence to be input to the generative AI model based on the collected log data. The input data for generating this prompt sentence is the log data collected in step 1. The server analyzes the log data and creates a prompt sentence in an appropriate format. For example, the format is "Analyze the following log data and propose the cause of the failure and how to deal with it. Log data: 2023-10-01 12:00:00 ERROR: port error on port 3."

[0227] Step 3:

[0228] The server inputs the generated prompt sentence into the generative AI model using the OpenAI API. This prompt sentence becomes the input. The generative AI model uses past fault response history and manufacturer manuals as learning data, and generates the cause of the fault and a solution based on the prompt sentence. The generated cause of the fault and a solution become the output.

[0229] Step 4:

[0230] The server outputs the cause of the failure and the countermeasure obtained from the generative AI model in natural language and presents it to the user. This output is displayed in a format that is easy for the user to understand. For example, it could be in the format of "There is a problem with port 3, so please restart the port." The server displays this information through a user interface.

[0231] Step 5:

[0232] The user repairs the factory robot based on the solution presented by the server. The user performs specific repair work according to the instructions from the server, such as restarting a port or replacing a cable. After the user completes the repair, he or she reports the completion of the repair to the server.

[0233] In this way, a rapid and accurate response can be made when a factory robot breaks down.

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

[0235] "Example 1"

[0236] As one embodiment of the present invention, a system including an emotion engine that recognizes the emotions of a user is provided. This system includes a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data. Furthermore, this generation AI includes an emotion engine that recognizes the emotions of a user. This emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and language, and adjusts the identification of the cause of the failure and the proposal of a countermeasure based on the emotion. For example, if the user is angry, the emotion engine conveys that information to the generation AI, and the generation AI proposes a more rapid countermeasure.

[0237] "Example 2"

[0238] As another embodiment, a system is provided in which an emotion engine determines the priority of fault handling based on the emotion of a user. This system is a further development of the system described in claim 4. Specifically, the emotion engine recognizes the emotion of a user and determines the priority of fault handling based on the emotion. For example, if a user is very angry, the emotion engine conveys that information to the generation AI, and the generation AI gives top priority to that fault handling. This enables more appropriate fault handling according to the emotion of the user.

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

[0240] "Example 1"

[0241] Step 1: Recognize the user's emotions The emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and choice of words.

[0242] Step 2: The emotion engine communicates the recognized user emotion to the generative AI.

[0243] Step 3: The generation AI adjusts the identification of the cause of the failure and the proposed solution based on the user's emotions. For example, if the user is angry, the generation AI will suggest a quicker solution. "Example 2"

[0244] Step 1: Recognize the user's emotions The emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and choice of words.

[0245] Step 2: The emotion engine communicates the recognized user emotion to the generative AI.

[0246] Step 3: The generative AI prioritizes the fault response based on the user's emotions. For example, if the user is very angry, the generative AI gives top priority to that fault response.

[0247] Example 1

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

[0249] Conventional troubleshooting systems often fail to quickly and accurately identify the cause of a malfunction or propose a solution, and they have a particular problem in that it is difficult to respond to the user's emotions. This leads to a decrease in user satisfaction and a deterioration in the efficiency of troubleshooting.

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

[0251] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using the past failure response history, the log data output by the information processing device when a failure occurs, and technical documents as learning data, a means for receiving the log data output by the information processing device when a failure occurs, a means including an emotion engine that recognizes the user's emotion, and a means for adjusting the proposed countermeasure based on the user's emotion information. This makes it possible to quickly and accurately identify the cause of the failure and propose an appropriate countermeasure according to the user's emotion.

[0252] The "past failure response history" is data that records the response methods and results of failures that have occurred in the past.

[0253] "Log data" refers to data that records events and error messages that are generated by an information processing device during its operation.

[0254] "Technical documentation" refers to documents that contain product specifications, operating instructions, troubleshooting guides, etc.

[0255] "Generative AI" is an artificial intelligence that uses learning data to identify the cause of a failure and suggest ways to deal with it.

[0256] The "emotion engine" is a system that recognizes emotions from the user's tone of voice, facial expressions, choice of words, etc.

[0257] "Information processing device" is a general term for devices that input, process, and output data.

[0258] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[0259] The present invention is a system that analyzes log data output when a failure occurs in a network device, identifies the cause of the failure based on past failure response history and technical documents, and proposes appropriate countermeasures.Furthermore, it has a function to recognize the user's emotions and propose countermeasures according to those emotions.

[0260] System Configuration

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

[0262] 1. Server

[0263] The server receives and analyzes the log data sent from the network devices. Specifically, the server monitors the log data in real time and saves the received data in a log file.

[0264] The server is equipped with a generation AI that uses past fault response history and technical documents as learning data. The generation AI analyzes the log data and identifies the cause of the fault.

[0265] 2. Terminal

[0266] The device is responsible for inputting the user's tone of voice, facial expressions, and vocabulary into the emotion engine. Specifically, the device uses a microphone and camera to capture the user's voice and video and transmits them to the emotion engine.

[0267] The terminal displays the solution sent from the server to the user.

[0268] 3. Emotion Engine

[0269] The emotion engine recognizes emotions from the user's tone of voice, facial expressions, vocabulary, etc. The emotion engine performs voice and image analysis to identify the user's emotional state (e.g. anger, sadness, joy).

[0270] The emotion engine conveys the recognized emotional information to the generative AI.

[0271] System Operation

[0272] 1. Data Entry

[0273] The server receives log data sent from the network device. For example, when the network device outputs log data of "link down", the server receives this information and stores it in a log file.

[0274] The device captures the user's tone of voice and facial expressions and sends them to the emotion engine.

[0275] 2. Data Processing

[0276] The server analyzes the received log data. Specifically, the server parses the contents of the log data and extracts error messages and warning messages.

[0277] The generation AI identifies the cause of the failure based on the analysis results and learning data. For example, the generation AI refers to the response history of past link downs and technical documentation and identifies the cause of the failure as a "broken cable."

[0278] The emotion engine recognizes "anger" from the tone of the user's voice and conveys that information to the generation AI.

[0279] 3. Proposal for solutions

[0280] The generation AI generates appropriate countermeasures in natural language based on the identified cause of the failure and the user's emotional information. For example, the generation AI refers to standard countermeasures for the cause of the failure and adjusts the proposed content according to the user's emotional state.

[0281] The server transmits the generated solution to the terminal, and the terminal displays the content of the solution to the user.

[0282] Examples

[0283] For example, when a network device outputs log data indicating "link down," the process proceeds as follows.

[0284] 1. The server receives the "link down" log data and saves it in a log file.

[0285] 2. The device captures the user's tone of voice and facial expressions and sends them to the emotion engine.

[0286] 3. The server parses the contents of the log data and extracts the "link down" error message.

[0287] 4. The generation AI refers to the response history of past link-downs and technical documentation, and identifies the cause of the failure as a "broken cable."

[0288] 5. The emotion engine recognizes "anger" from the tone of the user's voice and conveys that information to the generation AI.

[0289] 6. Based on the cause of the failure and the user's emotional information of "anger," the generative AI will suggest "replacing the cable immediately."

[0290] 7. The server sends the generated solution to the terminal, and the terminal displays it to the user.

[0291] Examples of prompt statements

[0292] "The network device has output log data indicating a link down. Please identify the cause of the failure based on past support history and technical documentation, and propose a quick response method in case the user is angry."

[0293] In this way, the system makes it possible to efficiently respond to network device failures and provides appropriate countermeasures according to the user's emotions.

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

[0295] Step 1:

[0296] The server receives log data sent from the network devices. Specifically, the server monitors the log data in real time and saves the received data in a log file. The input is the log data from the network devices, and the output is the saved log file.

[0297] Step 2:

[0298] The terminal inputs the user's tone of voice, facial expressions, and language into the emotion engine. Specifically, the terminal uses a microphone and camera mounted on the terminal to capture the user's voice and video and transmits them to the emotion engine. The input is the user's voice and video, and the output is the data transmitted to the emotion engine.

[0299] Step 3:

[0300] The server analyzes the received log data. Specifically, the server parses the contents of the log data and extracts error and warning messages. The input is the saved log file, and the output is the extracted error and warning messages.

[0301] Step 4:

[0302] The generation AI identifies the cause of the failure based on the analysis results and learning data. Specifically, the generation AI refers to past failure response history and technical documents to search for similar failure patterns. The inputs are the extracted error and warning messages and learning data, and the output is the identified cause of the failure.

[0303] Step 5:

[0304] The emotion engine recognizes the user's emotions and conveys that information to the generative AI. Specifically, the emotion engine performs voice and image analysis to identify the user's emotional state (e.g., anger, sadness, joy). The input is the user's voice and video, and the output is the recognized emotional information.

[0305] Step 6:

[0306] The generation AI generates appropriate countermeasures in natural language based on the identified cause of the failure and the user's emotional information. Specifically, the generation AI refers to standard countermeasures for the cause of the failure and adjusts the proposed content according to the user's emotional state. The input is the identified cause of the failure and the recognized emotional information, and the output is the generated countermeasure.

[0307] Step 7:

[0308] The server transmits the generated solution to the terminal, and the terminal displays the content to the user. Specifically, the server transmits the generated solution to the terminal, and the terminal displays the content on the screen. The input is the generated solution, and the output is the solution displayed to the user.

[0309] (Application example 1)

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

[0311] Conventional fault response systems often fail to quickly and accurately identify the cause of a fault or propose countermeasures, making it particularly difficult to respond flexibly to the user's emotions. In addition, when responding to faults in robots operating in factories, it is necessary to respond in a way that takes into account the emotions of the operator, but there was a lack of technology to achieve this.

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

[0313] In this invention, the server includes a means including a generation AI that uses past failure response history, log data output by the information processing device when a failure occurs, and technical documents as learning data to identify the cause of the failure and propose a countermeasure in natural language, a means for the generation AI to identify the cause of the failure from the log data output by the information processing device when a failure occurs, a means to propose a countermeasure based on the cause of the failure, a means including an emotion recognition engine that recognizes the user's emotions, and a means for the emotion recognition engine to recognize the user's emotions from the user's tone of voice, facial expression, and wording, and to adjust the identification of the cause of the failure and the proposal of the countermeasure based on the emotions. This makes it possible to quickly and accurately identify the cause of the failure and propose a flexible countermeasure according to the user's emotions.

[0314] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[0315] "Log data" is a record of events and errors generated by an information processing device during operation.

[0316] "Technical documentation" refers to documents that describe product or system specifications, operation methods, troubleshooting, etc.

[0317] "Generative AI" is artificial intelligence that generates new information based on training data and performs specific tasks.

[0318] An "emotion recognition engine" is a system that analyzes and recognizes emotions from a user's tone of voice, facial expressions, choice of words, etc.

[0319] "Identifying the cause of a failure" means clarifying the fundamental cause of a failure that has occurred.

[0320] "Proposing a solution" means presenting appropriate repair or response procedures based on the identified cause of the failure.

[0321] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[0322] "A user's tone of voice" refers to changes in pitch and intensity of the voice that indicate the speaker's emotions and intent.

[0323] "Facial expressions" are emotions and reactions shown by the movement of facial muscles.

[0324] "Language" refers to the words and expressions a speaker chooses to use, and reflects the speaker's feelings and attitudes.

[0325] A system for implementing the present invention includes an application called "Smart Maintenance Assistant" that is installed on a robot that operates in a factory. A specific embodiment of this system will be described below.

[0326] Hardware and Software Used

[0327] Hardware: Factory robots, microphones, cameras

[0328] Software: syslog parsing library (syslog_parser), emotion recognition library (emotion_recognition), generative AI model (ai_model)

[0329] System Configuration

[0330] 1. Identifying the cause of the failure:

[0331] The server analyzes in real time the log data that is output when the robot breaks down. Using a syslog analysis library, the server identifies the cause of the failure from the log data. Specifically, the server analyzes the log data based on past failure response history and technical documentation to clarify the root cause of the failure.

[0332] 2. Suggested solutions:

[0333] The server uses a generative AI model to propose appropriate countermeasures based on the identified cause of the failure. This generative AI model uses past failure response history and technical documents as learning data and proposes countermeasures in natural language.

[0334] 3. Emotion recognition:

[0335] The server uses emotion recognition libraries to analyze the user's tone of voice, facial expressions, and phrasing. Using microphones and cameras, it recognizes the user's emotions in real time. For example, if the user is angry, the emotion recognition engine passes that information to the generative AI model, which then trains it to suggest quick ways to deal with the situation.

[0336] Examples

[0337] For example, if a robot breaks down and "error code 123" is recorded in the log data, the server uses a syslog analysis library to identify the cause of "error code 123." It then uses a generative AI model to suggest countermeasures, such as "This is due to the motor overheating. Please check the cooling system."

[0338] Furthermore, if the user is angry when receiving this information, the emotion recognition engine will communicate that information to the generative AI model, suggesting faster and more specific ways to respond.

[0339] Examples of prompt statements

[0340] "Error code 123 has occurred. Please identify the cause of the failure based on past troubleshooting history and technical documentation, and propose an appropriate solution."

[0341] In this way, the smart maintenance assistant can streamline response to robot breakdowns in factories and enable flexible responses based on the emotions of operators.

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

[0343] Step 1:

[0344] The server receives log data output when a robot breaks down. The log data is sent in real time from the information processing device. The server analyzes this log data using a syslog analysis library (syslog_parser). Specifically, it extracts error codes and warning messages from the log data and compares them with past failure response history and technical documentation. This provides basic data for identifying the cause of the failure.

[0345] Input: Log data sent from the robot

[0346] Output: Extracted error codes and warning messages.

[0347] Step 2:

[0348] The server uses a syslog analysis library to analyze the extracted error codes and warning messages, and identifies the cause of the failure. It refers to past failure response history and technical documentation, and estimates the cause of the failure based on the response methods used when similar errors occurred. It uses a generative AI model (ai_model) to perform data calculations to identify the cause of the failure.

[0349] Input: Extracted error code or warning message

[0350] Output: Identified cause of failure

[0351] Step 3:

[0352] The server uses a generative AI model to propose an appropriate solution based on the identified cause of the failure. The generative AI model uses past failure response history and technical documents as learning data to generate a solution in natural language. The generated solution is presented to the user in natural language.

[0353] Input: Identified cause of failure

[0354] Output: Natural language generated instructions for action

[0355] Step 4:

[0356] The server uses an emotion recognition library (emotion_recognition) to analyze the user's tone of voice, facial expressions, and vocabulary. It uses a microphone and camera to recognize the user's emotions in real time. The emotion recognition engine conveys the user's emotion data to the generative AI model.

[0357] Input: The user's tone of voice, facial expressions, and language

[0358] Output: Recognized user emotion data

[0359] Step 5:

[0360] The server adjusts the generative AI model based on the user's emotion data obtained from the emotion recognition engine. For example, if the user is angry, the generative AI model is adjusted to suggest a quick solution. This makes it possible to propose flexible solutions according to the user's emotions.

[0361] Input: Recognized user emotion data

[0362] Output: Tailored action suggestions

[0363] Step 6:

[0364] The server presents the adjusted solution to the user. The user confirms the solution presented in natural language and takes the necessary action. This enables the cause of the failure to be identified quickly and accurately, and flexible solutions that correspond to the user's feelings are proposed.

[0365] Input: Adjusted response

[0366] Output: The action suggested to the user

[0367] Example 2

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

[0369] In conventional fault response systems, it was difficult to identify the cause of a network device fault and propose an appropriate method of dealing with the fault. In addition, it was not possible to determine the priority of fault response based on the user's emotions, and it was not possible to improve user satisfaction. This caused the problem that it was difficult to respond efficiently in the field where a prompt and appropriate fault response was required.

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

[0371] In this invention, the server includes: a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, log data output by the communication device when a failure occurs, and a manufacturer's manual as learning data; a means for the generation AI to identify the cause of the failure from the log data output by the communication device when a failure occurs, a means to propose a countermeasure based on the cause of the failure, a means including an emotion engine that recognizes the user's emotion and determines the priority of the failure response based on the emotion, and a means for the emotion engine to convey the user's emotion information to the generation AI and for the generation AI to determine the priority of the failure response based on the information. This enables a quick and appropriate failure response, and improves user satisfaction by determining the priority according to the user's emotion.

[0372] The "past failure response history" is data on the response methods and results recorded when a failure occurs in a communication device.

[0373] "Log data" refers to recorded information including error and warning messages generated by a communication device during operation.

[0374] A "manufacturer's manual" is a document that describes operating procedures and troubleshooting methods provided by the manufacturer of a communications device.

[0375] "Generative AI" is an artificial intelligence that uses past fault response history, log data, and manufacturer manuals as learning data to identify the cause of a fault and suggest countermeasures in natural language.

[0376] The "emotion engine" is a system that recognizes the user's emotions and determines the priority of troubleshooting based on those emotions.

[0377] "Communications equipment" refers to hardware devices used for data communication, such as network switches and routers.

[0378] "Natural language" refers to the language used by humans on a daily basis, and is the form of expression for the solutions proposed by generative AI.

[0379] "Priority" refers to the order in which one of multiple failure responses should be performed first.

[0380] The present invention is a system for identifying the cause of a failure in a communication device and proposing an appropriate countermeasure. The system is composed of a server, a terminal, and a user.

[0381] The server receives log data sent from the communication device and inputs it into the generative AI model. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data and analyzes the contents of the log data. For example, if the log data contains an error message "port error," the generative AI model determines that there is a problem with the port.

[0382] After identifying the cause of the failure, the generative AI model proposes appropriate countermeasures in natural language based on past failure response history. Specifically, it suggests countermeasures such as "restarting the port" or "replacing the cable." The server notifies the user of this suggested text.

[0383] The device is equipped with an emotion engine to recognize the user's emotions. The emotion engine analyzes emotions from the user's facial expressions and voice and sends the information to the server. The server inputs the emotion information received from the emotion engine into the generative AI model and determines the priority of fault response. For example, if the user is very angry, the emotion engine conveys that information to the generative AI model, and the generative AI model gives top priority to the fault response.

[0384] As a concrete example, consider a case where a network switch breaks down and an error message "port error" is output to the log data. In this case, the generative AI model receives the following prompt sentence as input:

[0385] Example prompt:

[0386] The error message "port error" was displayed in the log data of the network switch. What is the cause of the error and how can I solve it?

[0387] Based on this prompt, the generative AI model generates the following output:

[0388] Example output of a generative AI model:

[0389] The cause of the failure may be a problem with the port. To solve the problem, try the following steps:

[0390] 1. Restart the port.

[0391] 2. Try replacing the cable.

[0392] 3. If the problem persists, refer to the manufacturer's manual for further diagnosis.

[0393] In this way, the system processes a series of steps from receiving log data to identifying the cause of the failure, proposing countermeasures, and determining priorities based on the user's emotions. This enables quick and appropriate response to failures, and by determining priorities according to the user's emotions, it is possible to improve user satisfaction.

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

[0395] Step 1:

[0396] The server receives log data transmitted from the communication device. The log data is recorded information including the operating status of the communication device and error messages. The server temporarily stores the received log data.

[0397] Input: Log data sent from communication devices

[0398] Output: Temporarily stored log data

[0399] Specific behavior:

[0400] The server listens for log data messages sent from a communication device using the UDP protocol. When a log data message is received, the server stores the message in a log file.

[0401] Step 2:

[0402] The server inputs the received log data into the generative AI model, which then analyzes the contents of the log data and extracts important error messages.

[0403] Input: Temporarily stored log data

[0404] Output: Extracted error message

[0405] Specific behavior:

[0406] The server passes the log data messages in text format to the generative AI model, which then uses natural language processing techniques to analyze the contents of the log data and extract important error messages.

[0407] Step 3:

[0408] The generative AI model identifies the cause of the failure based on the extracted error message, and infers the cause of the failure by referring to past failure response history and manufacturer manuals.

[0409] Input: The extracted error message

[0410] Output: Identified cause of failure

[0411] Specific behavior:

[0412] The generative AI model analyzes error messages such as "port error" contained in the log data and compares them with a past database. For example, if a "port error" is included, the generative AI model determines that there is a problem with the port.

[0413] Step 4:

[0414] The generative AI model proposes appropriate countermeasures based on the identified cause of the failure, and the proposals are written in natural language and provided to the user.

[0415] Input: Identified cause of failure

[0416] Output: Natural language suggestions for how to address the issue

[0417] Specific behavior:

[0418] The generative AI model extracts countermeasures such as "restart the port" or "replace the cable" from the history of past fault handling, and generates a suggestion text in natural language. The server notifies the user of this suggestion text.

[0419] Step 5:

[0420] The terminal uses an emotion engine to recognize the user's emotion, which analyzes the user's emotion and transmits the information to the server.

[0421] Input: User facial expressions and voice

[0422] Output: Analyzed user emotion information

[0423] Specific behavior:

[0424] The device analyzes the user's emotions from their facial expressions and voice. For example, if the user is very angry, the emotion engine sends that information to the server.

[0425] Step 6:

[0426] The server inputs the emotional information received from the emotion engine into the generative AI model and determines the priority of fault response.

[0427] Input: Analyzed user emotion information

[0428] Output: Prioritized fault response

[0429] Specific behavior:

[0430] The server inputs the information from the emotion engine into the generative AI model, which then sets the priority of fault response as the highest priority based on that information.

[0431] In this way, the system processes a series of steps from receiving log data to identifying the cause of the failure, proposing countermeasures, and determining priorities based on the user's emotions.

[0432] (Application example 2)

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

[0434] In order to respond quickly and appropriately when a network device fails, it is important to identify the cause of the failure and propose a solution. However, in conventional systems, identifying the cause of the failure and proposing a solution are often done manually, which takes time and makes it difficult to respond while taking the user's emotions into account. In particular, in situations where a user is very angry, for example, where a response that takes into account priorities according to emotions is required, conventional systems are insufficient in their response.

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

[0436] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data, a means for monitoring syslogs sent from the network devices in real time, a means for the generation AI to analyze the syslog and identify the cause of the failure, a means including an emotion engine that recognizes the user's emotions and determines the priority of the failure response based on the emotions, and a means for proposing a countermeasure based on the cause of the failure and the priority. This makes it possible to quickly identify the cause of the failure and propose an appropriate countermeasure according to the user's emotions.

[0437] The "past failure response history" is a record of responses made to past failures of network devices.

[0438] "Syslog" is a system log output by network devices, and contains information such as the device's operating status and error messages.

[0439] A "manufacturer's manual" is an instruction manual or technical document provided by the manufacturer of network equipment, which describes the specifications of the equipment and how to respond in the event of a malfunction.

[0440] "Generative AI" is a system that uses artificial intelligence technology to identify the cause of a failure from training data and suggest ways to deal with it.

[0441] "Network equipment" refers to hardware devices used to build and operate networks, including routers and switches.

[0442] "Monitoring in real time" means instantly monitoring the syslog sent from network devices and immediately detecting abnormalities or failures.

[0443] An "emotion engine" is a technology that recognizes a user's emotions and adjusts the system's behavior based on those emotions.

[0444] "Deciding priorities" means deciding which of multiple failure responses should be performed first.

[0445] "Proposing a solution" means presenting appropriate countermeasures, such as repairs or setting changes, for the identified cause of the failure.

[0446] As an embodiment of the present invention, a method for installing a security AI assistant system on a smartphone will be described.

[0447] System Programming

[0448] The security AI assistant system includes the following main components:

[0449] 1. Syslog monitoring module: Monitors syslogs sent from network devices in real time.

[0450] 2. Generative AI module: Analyzes syslog and identifies the cause of failure.

[0451] 3. Emotion engine module: Recognizes user emotions and prioritizes fault responses based on those emotions.

[0452] 4. Countermeasure suggestion module: Proposes appropriate countermeasures based on the cause of the failure and priority.

[0453] Hardware and Software

[0454] Hardware: Smartphone

[0455] software:

[0456] Python

[0457] syslog_parser library (syslog parsing)

[0458] ai_model library (generative AI models)

[0459] emotion_engine library (emotion engine)

[0460] Data processing and calculation

[0461] 1. Syslog monitoring: The server uses the syslog_parser library to monitor syslogs sent from network devices in real time, allowing for immediate detection of abnormalities and failures.

[0462] 2. Identifying the cause of the failure: The server uses the generation AI module to analyze the monitored syslog and identify the cause of the failure. The generation AI uses past failure response history and manufacturer manuals as learning data.

[0463] 3. Emotion Recognition: The device uses the emotion engine module to recognize the user's emotions. For example, if the user is very angry, it conveys that information to the generation AI.

[0464] 4. Priority determination: The server determines the priority of fault handling based on the recognized user sentiment.

[0465] 5. Proposing countermeasures: The server proposes appropriate countermeasures to the user in natural language based on the cause of the failure and priority.

[0466] Examples

[0467] For example, if a network switch breaks down and the syslog contains the error message "port error," the generative AI will determine that there is a problem with the port. Based on past troubleshooting history, it will suggest "restart the port" or "replace the cable." Furthermore, if the user is very angry, the emotion engine will communicate that information to the generative AI, making troubleshooting the top priority.

[0468] Examples of prompt statements

[0469] syslog: "port error detected on port 3"

[0470] user_emotion: "angry"

[0471] By inputting this prompt sentence into a generative AI model, the cause of the failure is identified and a solution is suggested.

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

[0473] Step 1:

[0474] The server uses the syslog_parser library to monitor syslogs sent from network devices in real time. The input is the syslog sent from the network device, and the output is the parsed syslog message. When the server receives a syslog message, it immediately analyzes it to detect any abnormalities or signs of failure.

[0475] Step 2:

[0476] The server uses a generation AI module to receive the analyzed syslog message as input and identify the cause of the failure. The generation AI uses past failure response history and manufacturer manuals as learning data. The output is the identified cause of the failure. The server analyzes error messages and warnings contained in the syslog message and identifies the cause of the failure.

[0477] Step 3:

[0478] The device recognizes the user's emotions using an emotion engine module. The input is the user's voice and facial expression data, and the output is the recognized emotional state of the user. The device captures the user's voice and facial expressions through a camera and microphone, and the emotion engine analyzes them to identify the user's emotional state.

[0479] Step 4:

[0480] The server receives the recognized emotional state of the user as input and determines the priority of the fault response. The output is the determined priority. If the user is very angry, the server conveys that information to the generation AI, which gives the fault response the highest priority.

[0481] Step 5:

[0482] The server uses a generation AI module to propose an appropriate solution based on the cause of the failure and the priority order. The input is the identified cause of the failure and the determined priority order, and the output is the proposed solution. The generation AI of the server refers to past failure response history and manufacturer manuals, and proposes the optimal solution to the user in natural language.

[0483] Step 6:

[0484] The user receives the suggested solution from the server and actually takes action. The input is the solution suggested by the server, and the output is the result of the solution that was actually taken. The user takes action such as rebooting the port or replacing the cable according to the instructions from the server.

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

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

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

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

[0489] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0502] "Example 1"

[0503] One embodiment of the present invention is a system including a generation AI that uses past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data. This system receives as input the syslogs output by network devices when a failure occurs, and identifies the cause of the failure based on the learning data. Furthermore, based on the identified cause of the failure, the system proposes an appropriate countermeasure in natural language.

[0504] "Example 2"

[0505] As a specific example, consider the case where a network switch breaks down. The syslog output by the switch when a failure occurs is input to the generation AI. The generation AI identifies the cause of the failure from the syslog based on the history of past failures and the manufacturer's manual, which are used as learning data. For example, if the error message "port error" appears in the syslog,

[0506] If it does, the generative AI determines that there is a problem with the port and uses natural language suggestions to suggest solutions such as "restart the port" or "replace the cable" based on past troubleshooting history.

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

[0508] "Example 1"

[0509] Step 1: Input the syslog output by the network device when a failure occurs into the generation AI.

[0510] Step 2: The generating AI identifies the cause of the failure from the syslog based on past failure response history and manufacturer manuals used as learning data.

[0511] Step 3: Based on the identified cause of the failure, an appropriate countermeasure is suggested in natural language.

[0512] "Example 2"

[0513] Step 1: When a network switch fails, the syslog output by the switch at the time of the failure is input into the generation AI.

[0514] Step 2: The generated AI analyzes the error message (e.g. "porterror") contained in the syslog and determines that there is a problem with the port.

[0515] Step 3: The generative AI suggests solutions in natural language, such as "restart the port" or "replace the cable," based on past fault response history.

[0516] Example 1

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

[0518] When a failure occurs in network equipment, it is necessary to quickly and accurately identify the cause and provide the user with an appropriate solution. However, with conventional systems, it takes time to identify the cause of the failure and propose a solution, which means the user cannot respond quickly. In addition, it is difficult to effectively use past failure response history and manufacturer manuals, which can reduce the efficiency of failure response.

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

[0520] In this invention, the server includes a means for receiving log data transmitted from a network device, a means for analyzing the received log data and extracting an error message, a means for inputting the extracted error message to a generative AI model, a means for the generative AI model to use past failure response history, log data, and a manufacturer manual as learning data to identify the cause of the failure, a means for the generative AI model to generate an appropriate countermeasure in natural language based on the identified cause of the failure, and a means for notifying a user of the generated countermeasure. This makes it possible to quickly and accurately identify the cause of a failure in a network device and provide the user with an appropriate countermeasure.

[0521] A "network device" is a hardware device for conducting data communications, and includes routers, switches, firewalls, etc.

[0522] "Log data" refers to recorded information generated by network devices during operation, and includes error messages and warning messages.

[0523] An "error message" is warning information that is output when a network device detects a failure or abnormality.

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

[0525] "Failure response history" refers to data that records past failures and how they were handled.

[0526] A "manufacturer's manual" is a document that includes operating procedures and troubleshooting guides provided by the manufacturer of network equipment.

[0527] "Natural language" refers to the language used by humans on a daily basis, and is the form of response output by generative AI models.

[0528] "User" means an individual or organization that manages and operates network equipment.

[0529] A "notification" is an action in which the server conveys information to the user, and is carried out via email or the dashboard.

[0530] The present invention is a system for quickly and accurately identifying the cause of a fault in a network device and providing a user with an appropriate solution. A specific embodiment of this system will be described below.

[0531] Hardware and software used

[0532] Hardware: Server (e.g. general-purpose server)

[0533] Software: Generative AI models (e.g., general generative AI models), syslog analysis tools (e.g., general log analysis tools)

[0534] System Configuration

[0535] 1. The server receives log data sent from the network device. Specifically, the server functions as a syslog server and receives log data from the network device on port 514.

[0536] 2. The server analyzes the received log data and extracts error messages. Specifically, the server uses a log analysis tool to extract error messages and warning messages from the log data.

[0537] 3. The server prepares the extracted error message as data to be input to the generative AI model. Specifically, it formats the error message in text format and launches the generative AI model.

[0538] 4. The server inputs the error message into the generative AI model to identify the cause of the failure. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data, and estimates the cause of the failure based on the error message.

[0539] 5. The server uses a generative AI model to generate an appropriate solution based on the identified cause of the failure. The generative AI model proposes the solution in natural language.

[0540] 6. The server notifies the user of the generated solution. Specifically, the server provides the solution to the user via email or dashboard.

[0541] Examples

[0542] 1. The network device outputs log data containing the error message "Interface down."

[0543] 2. The server receives this log data and extracts the error message "Interface down."

[0544] 3. The server inputs the error message "Interface down" into the generative AI model.

[0545] 4. The generative AI model refers to past fault response history and manufacturer manuals to identify "broken cable" or "port failure" as the cause of "Interface down."

[0546] 5. The generative AI model then uses natural language to suggest solutions such as "check the cable and replace if necessary" or "restart the port."

[0547] 6. The server notifies the user of this solution.

[0548] Examples of prompt statements

[0549] "The log data from a network device contains the error message 'Interface down'. What is the cause of this error message and how can I resolve it?"

[0550] In this way, the server realizes a system that identifies the cause of a failure in a network device and provides the user with an appropriate solution.

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

[0552] Step 1:

[0553] The server receives log data sent from the network device. Specifically, the server functions as a syslog server and receives log data from the network device on port 514. The input is the log data from the network device, and the output is the received log data.

[0554] Step 2:

[0555] The server analyzes the received log data and extracts error messages. Specifically, it uses a log analysis tool to filter error messages and warning messages from the log data. The input is the received log data and the output is the extracted error messages.

[0556] Step 3:

[0557] The server prepares the extracted error message as data to be input to the generative AI model. Specifically, it formats the error message in text format and launches the generative AI model. The input is the extracted error message, and the output is the text data to be input to the generative AI model.

[0558] Step 4:

[0559] The server inputs error messages into the generative AI model and identifies the cause of the failure. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data, and estimates the cause of the failure based on the error message. The input is the text data input into the generative AI model, and the output is the identified cause of the failure.

[0560] Step 5:

[0561] The server uses a generative AI model to generate an appropriate solution based on the identified cause of the failure. The generative AI model proposes a solution in natural language. The input is the identified cause of the failure, and the output is the generated solution.

[0562] Step 6:

[0563] The server notifies the user of the generated solution. Specifically, the solution is provided to the user via email or a dashboard. The input is the generated solution, and the output is the solution notified to the user.

[0564] (Application example 1)

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

[0566] Robots operating in factories need to be diagnosed and repaired quickly and accurately when they break down. However, with conventional systems, it was difficult to identify the cause of the failure or propose an appropriate solution, and repairs often took a long time. There was also the problem that a technician with specialized knowledge was always needed, which increased costs. To solve these issues, a system was needed that could quickly identify the cause of the failure and automatically propose an appropriate solution.

[0567] The identification process by the identification processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means. In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslog output by a network device when a failure occurs, and manufacturer manuals as learning data, a means for diagnosing a failure and providing repair support for a robot operating in a factory, a means for analyzing the syslog output by a robot when a failure occurs and identifying the cause of the failure, and a means for proposing an appropriate countermeasure in natural language based on the identified cause of the failure. This makes it possible to quickly identify the cause of the failure and automatically propose an appropriate countermeasure.

[0568] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[0569] The "syslog output by a network device when a failure occurs" is log data that is generated when a network device fails, and includes detailed information about the failure.

[0570] "Manufacturer's Manual" means an instruction manual or technical documentation provided by a product manufacturer that includes information on how to use the product and troubleshooting.

[0571] "Generative AI" is artificial intelligence that generates new information based on learning data, identifying the cause of failures and proposing countermeasures.

[0572] A "factory robot" is an automated machine designed to perform tasks in a factory.

[0573] "Fault diagnosis" is the analytical process for determining the cause of a fault.

[0574] "Repair assistance" refers to the provision of information and assistance to assist in the repair of broken equipment.

[0575] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[0576] "Analysis" is the process of examining data in detail to understand its meaning and structure.

[0577] "Solutions" are specific actions or steps to be taken in response to an identified problem.

[0578] In order to implement the present invention, the following system configuration and program are required.

[0579] The server contains a generative AI model that uses past fault response history, syslogs output by network devices when a fault occurs, and manufacturer manuals as learning data. This generative AI model analyzes the syslogs output by the robot when a fault occurs and identifies the cause of the fault. It also proposes appropriate countermeasures in natural language based on the identified cause of the fault.

[0580] Specifically, the server performs the following process.

[0581] 1. Data collection and analysis:

[0582] The server receives syslog data sent from robots operating in the factory. The received syslog data is parsed using the syslog_parser module. This analysis extracts detailed information about the failure.

[0583] 2. Identifying the cause of the failure:

[0584] The analyzed data is input to the generative AI model, which has learned from past fault response history and manufacturer manuals, and identifies the cause of the fault based on this. The ai_model module is used for this identification.

[0585] 3. Suggested solutions:

[0586] Based on the identified fault causes, the generative AI model generates appropriate countermeasures, which are generated using the ai_model module. The generated countermeasures are then converted into natural language using the natural_language_processor module.

[0587] 4. Notice to Users:

[0588] The solution converted into natural language is notified to the user, so that the user can quickly take the appropriate solution.

[0589] As a concrete example, by inputting the following prompt sentence into the generative AI model, the cause of the failure and how to deal with it can be identified.

[0590] Prompt text: "2023-10-01 12:00:00 ERROR: Motor failure in section A"

[0591] Using this prompt as input, the generative AI model produces the following output:

[0592] Output: "A motor failure has occurred in section A. Please attempt to restart the motor based on past failure history and manufacturer manual. If restarting is unsuccessful, the motor will need to be replaced."

[0593] In this way, the server can quickly identify the cause of a failure and automatically suggest appropriate countermeasures, which will efficiently diagnose failures and provide repair support for robots operating in factories.

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

[0595] Step 1:

[0596] The server receives syslog data sent from robots operating in the factory. The input is the syslog data from the robot, and the output is the received syslog data. This data includes detailed information such as the time when the failure occurred and error messages.

[0597] Step 2:

[0598] The server parses the received syslog data using the syslog_parser module. The input is the received syslog data, and the output is the parsed failure information. This parsing extracts detailed information such as error messages and the location of the failure.

[0599] Step 3:

[0600] The server inputs the analyzed failure information into the generative AI model. The input is the analyzed failure information, and the output is the identified cause of the failure. The generative AI model learns from past failure response history and manufacturer manuals, and identifies the cause of the failure based on this.

[0601] Step 4:

[0602] The server uses a generative AI model to generate appropriate countermeasures based on the identified cause of the failure. The input is the identified cause of the failure, and the output is the generated countermeasure. The countermeasure is generated based on the history of past failure responses and the manufacturer's manual.

[0603] Step 5:

[0604] The server converts the generated action into natural language using the natural_language_processor module. The input is the generated action and the output is the action converted into natural language. This conversion provides the action in a form that is easy for the user to understand.

[0605] Step 6:

[0606] The server notifies the user of the solution converted into natural language. The input is the solution converted into natural language, and the output is a notification to the user. This allows the user to quickly take appropriate measures.

[0607] Example 2

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

[0609] When network equipment fails, there is a need to quickly and accurately identify the cause of the failure and propose appropriate countermeasures. However, with conventional systems, it takes time to identify the cause of the failure and propose countermeasures, and engineers with specialized knowledge are required, making it difficult to respond to failures efficiently.

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

[0611] In this invention, the server includes a means for receiving log data transmitted from a network device, a means for analyzing the log data and extracting an error message, a means for inputting the extracted error message into a generative AI model and identifying the cause of a failure, a means for proposing a countermeasure based on the cause of the failure by the generative AI model, and a means for notifying a user of the proposed countermeasure. This makes it possible to quickly and accurately identify the cause of a failure and propose an appropriate countermeasure.

[0612] A "network device" is a hardware device for data communication, including routers and switches.

[0613] "Log data" refers to recorded information generated by a network device during operation, and includes error messages and event information.

[0614] An "error message" is a message that is output by a network device when it detects an abnormality, and contains information that is useful for identifying the cause of the failure.

[0615] A "generative AI model" is a model that is trained using artificial intelligence technology to perform specific tasks, such as identifying the cause of a failure and proposing countermeasures based on past data and technical documentation.

[0616] The "cause of failure" is a factor that prevents a network device from operating normally, and is identified from error messages and log data.

[0617] A "remedy" is a remedial measure taken to address the identified cause of the failure, such as rebooting the port or replacing the cable.

[0618] "User" means a person or organization that manages and operates network equipment and is the recipient of troubleshooting proposals.

[0619] The present invention is a system for quickly and accurately identifying the cause of a failure when a network device fails and proposing an appropriate countermeasure. A specific embodiment of this system will be described below.

[0620] The server receives log data sent from the network devices. The log data includes the operating status of the network devices and error messages. The server analyzes the received log data and extracts error messages. This analysis includes checking the format of the data and extracting error messages.

[0621] Next, the server inputs the extracted error message into the generative AI model. The generative AI model uses past fault response history and technical documents as learning data and identifies the cause of the fault from the error message. For example, if the error message contains "port error," the generative AI model will determine that there is a problem with the port.

[0622] After the cause of the failure is identified, the server uses a generative AI model to suggest appropriate countermeasures. The suggestions are generated based on past failure response history and technical documentation. For example, countermeasures such as "restart the port" or "replace the cable" are suggested.

[0623] Finally, the server notifies the user of the proposed solution. Possible notification methods include email and display on the dashboard. This allows the user to quickly identify the cause of the failure and implement the appropriate solution.

[0624] To illustrate, consider the following scenario:

[0625] The server receives log data "2023-10-01 12:00:00 port error detected on port 3" from the network device.

[0626] The server analyzes this log data and extracts the error message "port error."

[0627] The server inputs the extracted error messages into a generative AI model to identify the cause of the failure.

[0628] The generative AI model determines that there is a problem with the port and suggests restarting the port or replacing the cable.

[0629] The server will notify the user of the proposal via email.

[0630] Example prompt:

[0631] Syslog data: "2023-10-01 12:00:00 port error detected on port 3"

[0632] Prompt for generative AI model: "Please identify the cause of the failure from this syslog data and suggest appropriate countermeasures."

[0633] In this way, the server can receive log data, analyze it, and use a generative AI model to identify the cause of the failure and notify the user of the appropriate course of action.

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

[0635] Step 1:

[0636] The server receives the log data transmitted from the network device.

[0637] Specifically, the server listens to a network port and receives log data in real time, which is then temporarily stored.

[0638] Input: Log data from network devices

[0639] Output: Temporarily saved log data

[0640] Step 2:

[0641] The server analyzes the received log data and extracts error messages.

[0642] Specifically, the server checks the format of the log data and extracts the part containing the error message. Regular expressions and pattern matching techniques are used for analysis.

[0643] Input: Temporarily saved log data

[0644] Output: Extracted error message

[0645] Step 3:

[0646] The server inputs the extracted error messages into a generative AI model to identify the cause of the failure.

[0647] Specifically, the server inputs the error message as a prompt to the generative AI model, which then identifies the cause of the failure based on past failure response history and technical documentation.

[0648] Input: The extracted error message

[0649] Output: Identified cause of failure

[0650] Step 4:

[0651] The server then suggests countermeasures based on the causes of the failure identified using the generative AI model.

[0652] Specifically, the server generates appropriate countermeasures based on the cause of the failure obtained from the generative AI model. Countermeasures are proposed based on past failure response history and technical documentation.

[0653] Input: Identified cause of failure

[0654] Output: Suggested action to be taken

[0655] Step 5:

[0656] The server will notify the user of the suggested course of action.

[0657] Specifically, the server retrieves the user's contact information and sends the suggestions via email or dashboard.

[0658] Input: Proposed action

[0659] Output:Notification to the user

[0660] In this way, the server can receive log data, analyze it, and use a generative AI model to identify the cause of the failure and notify the user of the appropriate course of action.

[0661] (Application example 2)

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

[0663] When a factory robot breaks down, it is necessary to quickly and accurately identify the cause of the failure and propose an appropriate solution. However, with conventional systems, it takes time to identify the cause of the failure and propose a solution, which prolongs factory downtime. In addition, there is also the issue of the constant need for engineers with specialized knowledge, which is costly.

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

[0665] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, log data output by the network device when a failure occurs, and the manufacturer's manual as learning data, a means for analyzing in real time the log data generated when the factory robot breaks down, a means for proposing a specific countermeasure based on the past failure response history and the manufacturer's manual, and a means for outputting the generated cause of the failure and the countermeasure in natural language. This enables a quick and accurate response when the factory robot breaks down.

[0666] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[0667] The "log data output by a network device when a failure occurs" is data that includes error messages and status information that are generated when a network device fails.

[0668] A "manufacturer's manual" is a document provided by a manufacturer regarding how to use and troubleshoot a device.

[0669] "Generative AI" is artificial intelligence that learns from past data and identifies the cause of failures and generates countermeasures based on new data.

[0670] A "factory robot" is a mechanical device used to perform automated tasks in a factory.

[0671] "Real-time analysis" means analyzing data as soon as it is generated.

[0672] "Providing suggestions in natural language" means presenting solutions in terms that are easy for humans to understand.

[0673] A "cause of failure" is a factor that causes equipment to not operate normally.

[0674] A "measure" is a method for correcting a malfunction and returning the equipment to a normal state.

[0675] The system for carrying out the present invention is for quickly and accurately dealing with the breakdown of a factory robot. A specific embodiment of the system is described below.

[0676] System Configuration

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

[0678] 1. Server: A computer system for running the generative AI model.

[0679] 2. Factory Robot: A mechanical device that performs automated tasks in a factory.

[0680] 3. Network equipment: Equipment for communication between the robot and the server.

[0681] Hardware and Software Used

[0682] Hardware: Factory robots, servers, network equipment

[0683] Software: Python, OpenAI API

[0684] Data processing and calculation

[0685] Server Processing

[0686] 1. Log data collection: The server collects log data generated when a factory robot breaks down.

[0687] 2. Prompt sentence generation: The server generates prompt sentences to be input into the generative AI model based on the collected log data.

[0688] 3. Analysis by generative AI: The server uses the OpenAI API to input prompt text into the generative AI model to generate the cause of the failure and a solution.

[0689] 4. Output of results: The server outputs the generated cause of the fault and how to deal with it in natural language and presents it to the user.

[0690] Examples

[0691] For example, if a factory robot generates log data containing the error message "port error on port 3," the server inputs the following prompt sentence into the generative AI model:

[0692] Examples of prompt statements

[0693] Please analyze the following log data and suggest the cause of the failure and how to deal with it.

[0694] Log data: 2023-10-01 12:00:00 ERROR: port error on port 3

[0695] Based on this prompt, the generative AI model determines that "there is a problem with port 3" and suggests solutions such as "restarting the port" or "replacing the cable."

[0696] effect

[0697] This system enables a rapid and accurate response when a factory robot breaks down, minimizing factory downtime. It also contributes to cost reduction because engineers with specialized knowledge are not always required.

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

[0699] Step 1:

[0700] The server collects log data that is generated when a factory robot breaks down. The log data includes error messages and status information. This log data is input. The server receives the log data via the network and stores it in a database.

[0701] Step 2:

[0702] The server generates a prompt sentence to be input to the generative AI model based on the collected log data. The input data for generating this prompt sentence is the log data collected in step 1. The server analyzes the log data and creates a prompt sentence in an appropriate format. For example, the format is "Analyze the following log data and propose the cause of the failure and how to deal with it. Log data: 2023-10-01 12:00:00 ERROR: port error on port 3."

[0703] Step 3:

[0704] The server inputs the generated prompt sentence into the generative AI model using the OpenAI API. This prompt sentence becomes the input. The generative AI model uses past fault response history and manufacturer manuals as learning data, and generates the cause of the fault and a solution based on the prompt sentence. The generated cause of the fault and a solution become the output.

[0705] Step 4:

[0706] The server outputs the cause of the failure and the countermeasure obtained from the generative AI model in natural language and presents it to the user. This output is displayed in a format that is easy for the user to understand. For example, it could be in the format of "There is a problem with port 3, so please restart the port." The server displays this information through a user interface.

[0707] Step 5:

[0708] The user repairs the factory robot based on the solution presented by the server. The user performs specific repair work according to the instructions from the server, such as restarting a port or replacing a cable. After the user completes the repair, he or she reports the completion of the repair to the server.

[0709] In this way, a rapid and accurate response can be made when a factory robot breaks down.

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

[0711] "Example 1"

[0712] As one embodiment of the present invention, a system including an emotion engine that recognizes the emotions of a user is provided. This system includes a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data. Furthermore, this generation AI includes an emotion engine that recognizes the emotions of a user. This emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and language, and adjusts the identification of the cause of the failure and the proposal of a countermeasure based on the emotion. For example, if the user is angry, the emotion engine conveys that information to the generation AI, and the generation AI proposes a more rapid countermeasure.

[0713] "Example 2"

[0714] As another embodiment, a system is provided in which an emotion engine determines the priority of fault handling based on the emotion of a user. This system is a further development of the system described in claim 4. Specifically, the emotion engine recognizes the emotion of a user and determines the priority of fault handling based on the emotion. For example, if a user is very angry, the emotion engine conveys that information to the generation AI, and the generation AI gives top priority to that fault handling. This enables more appropriate fault handling according to the emotion of the user.

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

[0716] "Example 1"

[0717] Step 1: Recognize the user's emotions The emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and choice of words.

[0718] Step 2: The emotion engine communicates the recognized user emotion to the generative AI.

[0719] Step 3: The generation AI adjusts the identification of the cause of the failure and the proposed solution based on the user's emotions. For example, if the user is angry, the generation AI will suggest a quicker solution. "Example 2"

[0720] Step 1: Recognize the user's emotions The emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and choice of words.

[0721] Step 2: The emotion engine communicates the recognized user emotion to the generative AI.

[0722] Step 3: The generative AI prioritizes the fault response based on the user's emotions. For example, if the user is very angry, the generative AI gives top priority to that fault response.

[0723] Example 1

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

[0725] Conventional troubleshooting systems often fail to quickly and accurately identify the cause of a malfunction or propose a solution, and they have a particular problem in that it is difficult to respond to the user's emotions. This leads to a decrease in user satisfaction and a deterioration in the efficiency of troubleshooting.

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

[0727] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using the past failure response history, the log data output by the information processing device when a failure occurs, and technical documents as learning data, a means for receiving the log data output by the information processing device when a failure occurs, a means including an emotion engine that recognizes the user's emotion, and a means for adjusting the proposed countermeasure based on the user's emotion information. This makes it possible to quickly and accurately identify the cause of the failure and propose an appropriate countermeasure according to the user's emotion.

[0728] The "past failure response history" is data that records the response methods and results of failures that have occurred in the past.

[0729] "Log data" refers to data that records events and error messages that are generated by an information processing device during its operation.

[0730] "Technical documentation" refers to documents that contain product specifications, operating instructions, troubleshooting guides, etc.

[0731] "Generative AI" is an artificial intelligence that uses learning data to identify the cause of a failure and suggest ways to deal with it.

[0732] The "emotion engine" is a system that recognizes emotions from the user's tone of voice, facial expressions, choice of words, etc.

[0733] "Information processing device" is a general term for devices that input, process, and output data.

[0734] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[0735] The present invention is a system that analyzes log data output when a failure occurs in a network device, identifies the cause of the failure based on past failure response history and technical documents, and proposes appropriate countermeasures.Furthermore, it has a function to recognize the user's emotions and propose countermeasures according to those emotions.

[0736] System Configuration

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

[0738] 1. Server

[0739] The server receives and analyzes the log data sent from the network devices. Specifically, the server monitors the log data in real time and saves the received data in a log file.

[0740] The server is equipped with a generation AI that uses past fault response history and technical documents as learning data. The generation AI analyzes the log data and identifies the cause of the fault.

[0741] 2. Terminal

[0742] The device is responsible for inputting the user's tone of voice, facial expressions, and vocabulary into the emotion engine. Specifically, the device uses a microphone and camera to capture the user's voice and video and transmits them to the emotion engine.

[0743] The terminal displays the solution sent from the server to the user.

[0744] 3. Emotion Engine

[0745] The emotion engine recognizes emotions from the user's tone of voice, facial expressions, vocabulary, etc. The emotion engine performs voice and image analysis to identify the user's emotional state (e.g. anger, sadness, joy).

[0746] The emotion engine conveys the recognized emotional information to the generative AI.

[0747] System Operation

[0748] 1. Data Entry

[0749] The server receives log data sent from the network device. For example, when the network device outputs log data of "link down", the server receives this information and stores it in a log file.

[0750] The device captures the user's tone of voice and facial expressions and sends them to the emotion engine.

[0751] 2. Data Processing

[0752] The server analyzes the received log data. Specifically, the server parses the contents of the log data and extracts error messages and warning messages.

[0753] The generation AI identifies the cause of the failure based on the analysis results and learning data. For example, the generation AI refers to the response history of past link downs and technical documentation and identifies the cause of the failure as a "broken cable."

[0754] The emotion engine recognizes "anger" from the tone of the user's voice and conveys that information to the generation AI.

[0755] 3. Proposal for solutions

[0756] The generation AI generates appropriate countermeasures in natural language based on the identified cause of the failure and the user's emotional information. For example, the generation AI refers to standard countermeasures for the cause of the failure and adjusts the proposed content according to the user's emotional state.

[0757] The server transmits the generated solution to the terminal, and the terminal displays the content of the solution to the user.

[0758] Examples

[0759] For example, when a network device outputs log data indicating "link down," the process proceeds as follows.

[0760] 1. The server receives the "link down" log data and saves it in a log file.

[0761] 2. The device captures the user's tone of voice and facial expressions and sends them to the emotion engine.

[0762] 3. The server parses the contents of the log data and extracts the "link down" error message.

[0763] 4. The generation AI refers to the response history of past link-downs and technical documentation, and identifies the cause of the failure as a "broken cable."

[0764] 5. The emotion engine recognizes "anger" from the tone of the user's voice and conveys that information to the generation AI.

[0765] 6. Based on the cause of the failure and the user's emotional information of "anger," the generative AI will suggest "replacing the cable immediately."

[0766] 7. The server sends the generated solution to the terminal, and the terminal displays it to the user.

[0767] Examples of prompt statements

[0768] "The network device has output log data indicating a link down. Please identify the cause of the failure based on past support history and technical documentation, and propose a quick response method in case the user is angry."

[0769] In this way, the system makes it possible to efficiently respond to network device failures and provides appropriate countermeasures according to the user's emotions.

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

[0771] Step 1:

[0772] The server receives log data sent from the network devices. Specifically, the server monitors the log data in real time and saves the received data in a log file. The input is the log data from the network devices, and the output is the saved log file.

[0773] Step 2:

[0774] The terminal inputs the user's tone of voice, facial expressions, and language into the emotion engine. Specifically, the terminal uses a microphone and camera mounted on the terminal to capture the user's voice and video and transmits them to the emotion engine. The input is the user's voice and video, and the output is the data transmitted to the emotion engine.

[0775] Step 3:

[0776] The server analyzes the received log data. Specifically, the server parses the contents of the log data and extracts error and warning messages. The input is the saved log file, and the output is the extracted error and warning messages.

[0777] Step 4:

[0778] The generation AI identifies the cause of the failure based on the analysis results and learning data. Specifically, the generation AI refers to past failure response history and technical documents to search for similar failure patterns. The inputs are the extracted error and warning messages and learning data, and the output is the identified cause of the failure.

[0779] Step 5:

[0780] The emotion engine recognizes the user's emotions and conveys that information to the generative AI. Specifically, the emotion engine performs voice and image analysis to identify the user's emotional state (e.g., anger, sadness, joy). The input is the user's voice and video, and the output is the recognized emotional information.

[0781] Step 6:

[0782] The generation AI generates appropriate countermeasures in natural language based on the identified cause of the failure and the user's emotional information. Specifically, the generation AI refers to standard countermeasures for the cause of the failure and adjusts the proposed content according to the user's emotional state. The input is the identified cause of the failure and the recognized emotional information, and the output is the generated countermeasure.

[0783] Step 7:

[0784] The server transmits the generated solution to the terminal, and the terminal displays the content to the user. Specifically, the server transmits the generated solution to the terminal, and the terminal displays the content on the screen. The input is the generated solution, and the output is the solution displayed to the user.

[0785] (Application example 1)

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

[0787] Conventional fault response systems often fail to quickly and accurately identify the cause of a fault or propose countermeasures, making it particularly difficult to respond flexibly to the user's emotions. In addition, when responding to faults in robots operating in factories, it is necessary to respond in a way that takes into account the emotions of the operator, but there was a lack of technology to achieve this.

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

[0789] In this invention, the server includes a means including a generation AI that uses past failure response history, log data output by the information processing device when a failure occurs, and technical documents as learning data to identify the cause of the failure and propose a countermeasure in natural language, a means for the generation AI to identify the cause of the failure from the log data output by the information processing device when a failure occurs, a means to propose a countermeasure based on the cause of the failure, a means including an emotion recognition engine that recognizes the user's emotions, and a means for the emotion recognition engine to recognize the user's emotions from the user's tone of voice, facial expression, and wording, and to adjust the identification of the cause of the failure and the proposal of the countermeasure based on the emotions. This makes it possible to quickly and accurately identify the cause of the failure and propose a flexible countermeasure according to the user's emotions.

[0790] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[0791] "Log data" is a record of events and errors generated by an information processing device during operation.

[0792] "Technical documentation" refers to documents that describe product or system specifications, operation methods, troubleshooting, etc.

[0793] "Generative AI" is artificial intelligence that generates new information based on training data and performs specific tasks.

[0794] An "emotion recognition engine" is a system that analyzes and recognizes emotions from a user's tone of voice, facial expressions, choice of words, etc.

[0795] "Identifying the cause of a failure" means clarifying the fundamental cause of a failure that has occurred.

[0796] "Proposing a solution" means presenting appropriate repair or response procedures based on the identified cause of the failure.

[0797] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[0798] "A user's tone of voice" refers to changes in pitch and intensity of the voice that indicate the speaker's emotions and intent.

[0799] "Facial expressions" are emotions and reactions shown by the movement of facial muscles.

[0800] "Language" refers to the words and expressions a speaker chooses to use, and reflects the speaker's feelings and attitudes.

[0801] A system for implementing the present invention includes an application called "Smart Maintenance Assistant" that is installed on a robot that operates in a factory. A specific embodiment of this system will be described below.

[0802] Hardware and Software Used

[0803] Hardware: Factory robots, microphones, cameras

[0804] Software: syslog parsing library (syslog_parser), emotion recognition library (emotion_recognition), generative AI model (ai_model)

[0805] System Configuration

[0806] 1. Identifying the cause of the failure:

[0807] The server analyzes in real time the log data that is output when the robot breaks down. Using a syslog analysis library, the server identifies the cause of the failure from the log data. Specifically, the server analyzes the log data based on past failure response history and technical documentation to clarify the root cause of the failure.

[0808] 2. Suggested solutions:

[0809] The server uses a generative AI model to propose appropriate countermeasures based on the identified cause of the failure. This generative AI model uses past failure response history and technical documents as learning data and proposes countermeasures in natural language.

[0810] 3. Emotion recognition:

[0811] The server uses emotion recognition libraries to analyze the user's tone of voice, facial expressions, and phrasing. Using microphones and cameras, it recognizes the user's emotions in real time. For example, if the user is angry, the emotion recognition engine passes that information to the generative AI model, which then trains it to suggest quick ways to deal with the situation.

[0812] Examples

[0813] For example, if a robot breaks down and "error code 123" is recorded in the log data, the server uses a syslog analysis library to identify the cause of "error code 123." It then uses a generative AI model to suggest countermeasures, such as "This is due to the motor overheating. Please check the cooling system."

[0814] Furthermore, if the user is angry when receiving this information, the emotion recognition engine will communicate that information to the generative AI model, suggesting faster and more specific ways to respond.

[0815] Examples of prompt statements

[0816] "Error code 123 has occurred. Please identify the cause of the failure based on past troubleshooting history and technical documentation, and propose an appropriate solution."

[0817] In this way, the smart maintenance assistant can streamline response to robot breakdowns in factories and enable flexible responses based on the emotions of operators.

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

[0819] Step 1:

[0820] The server receives log data output when a robot breaks down. The log data is sent in real time from the information processing device. The server analyzes this log data using a syslog analysis library (syslog_parser). Specifically, it extracts error codes and warning messages from the log data and compares them with past failure response history and technical documentation. This provides basic data for identifying the cause of the failure.

[0821] Input: Log data sent from the robot

[0822] Output: Extracted error codes and warning messages.

[0823] Step 2:

[0824] The server uses a syslog analysis library to analyze the extracted error codes and warning messages, and identifies the cause of the failure. It refers to past failure response history and technical documentation, and estimates the cause of the failure based on the response methods used when similar errors occurred. It uses a generative AI model (ai_model) to perform data calculations to identify the cause of the failure.

[0825] Input: Extracted error code or warning message

[0826] Output: Identified cause of failure

[0827] Step 3:

[0828] The server uses a generative AI model to propose an appropriate solution based on the identified cause of the failure. The generative AI model uses past failure response history and technical documents as learning data to generate a solution in natural language. The generated solution is presented to the user in natural language.

[0829] Input: Identified cause of failure

[0830] Output: Natural language generated instructions for action

[0831] Step 4:

[0832] The server uses an emotion recognition library (emotion_recognition) to analyze the user's tone of voice, facial expressions, and vocabulary. It uses a microphone and camera to recognize the user's emotions in real time. The emotion recognition engine conveys the user's emotion data to the generative AI model.

[0833] Input: The user's tone of voice, facial expressions, and language

[0834] Output: Recognized user emotion data

[0835] Step 5:

[0836] The server adjusts the generative AI model based on the user's emotion data obtained from the emotion recognition engine. For example, if the user is angry, the generative AI model is adjusted to suggest a quick solution. This makes it possible to propose flexible solutions according to the user's emotions.

[0837] Input: Recognized user emotion data

[0838] Output: Tailored action suggestions

[0839] Step 6:

[0840] The server presents the adjusted solution to the user. The user confirms the solution presented in natural language and takes the necessary action. This enables the cause of the failure to be identified quickly and accurately, and flexible solutions that correspond to the user's feelings are proposed.

[0841] Input: Adjusted response

[0842] Output: The action suggested to the user

[0843] Example 2

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

[0845] In conventional fault response systems, it was difficult to identify the cause of a network device fault and propose an appropriate method of dealing with the fault. In addition, it was not possible to determine the priority of fault response based on the user's emotions, and it was not possible to improve user satisfaction. This caused the problem that it was difficult to respond efficiently in the field where a prompt and appropriate fault response was required.

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

[0847] In this invention, the server includes: a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, log data output by the communication device when a failure occurs, and a manufacturer's manual as learning data; a means for the generation AI to identify the cause of the failure from the log data output by the communication device when a failure occurs, a means to propose a countermeasure based on the cause of the failure, a means including an emotion engine that recognizes the user's emotion and determines the priority of the failure response based on the emotion, and a means for the emotion engine to convey the user's emotion information to the generation AI and for the generation AI to determine the priority of the failure response based on the information. This enables a quick and appropriate failure response, and improves user satisfaction by determining the priority according to the user's emotion.

[0848] The "past failure response history" is data on the response methods and results recorded when a failure occurs in a communication device.

[0849] "Log data" refers to recorded information including error and warning messages generated by a communication device during operation.

[0850] A "manufacturer's manual" is a document that describes operating procedures and troubleshooting methods provided by the manufacturer of a communications device.

[0851] "Generative AI" is an artificial intelligence that uses past fault response history, log data, and manufacturer manuals as learning data to identify the cause of a fault and suggest countermeasures in natural language.

[0852] The "emotion engine" is a system that recognizes the user's emotions and determines the priority of troubleshooting based on those emotions.

[0853] "Communications equipment" refers to hardware devices used for data communication, such as network switches and routers.

[0854] "Natural language" refers to the language used by humans on a daily basis, and is the form of expression for the solutions proposed by generative AI.

[0855] "Priority" refers to the order in which one of multiple failure responses should be performed first.

[0856] The present invention is a system for identifying the cause of a failure in a communication device and proposing an appropriate countermeasure. The system is composed of a server, a terminal, and a user.

[0857] The server receives log data sent from the communication device and inputs it into the generative AI model. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data and analyzes the contents of the log data. For example, if the log data contains an error message "port error," the generative AI model determines that there is a problem with the port.

[0858] After identifying the cause of the failure, the generative AI model proposes appropriate countermeasures in natural language based on past failure response history. Specifically, it suggests countermeasures such as "restarting the port" or "replacing the cable." The server notifies the user of this suggested text.

[0859] The device is equipped with an emotion engine to recognize the user's emotions. The emotion engine analyzes emotions from the user's facial expressions and voice and sends the information to the server. The server inputs the emotion information received from the emotion engine into the generative AI model and determines the priority of fault response. For example, if the user is very angry, the emotion engine conveys that information to the generative AI model, and the generative AI model gives top priority to the fault response.

[0860] As a concrete example, consider a case where a network switch breaks down and an error message "port error" is output to the log data. In this case, the generative AI model receives the following prompt sentence as input:

[0861] Example prompt:

[0862] The error message "port error" was displayed in the log data of the network switch. What is the cause of the error and how can I solve it?

[0863] Based on this prompt, the generative AI model generates the following output:

[0864] Example output of a generative AI model:

[0865] The cause of the failure may be a problem with the port. To solve the problem, try the following steps:

[0866] 1. Restart the port.

[0867] 2. Try replacing the cable.

[0868] 3. If the problem persists, refer to the manufacturer's manual for further diagnosis.

[0869] In this way, the system processes a series of steps from receiving log data to identifying the cause of the failure, proposing countermeasures, and determining priorities based on the user's emotions. This enables quick and appropriate response to failures, and by determining priorities according to the user's emotions, it is possible to improve user satisfaction.

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

[0871] Step 1:

[0872] The server receives log data transmitted from the communication device. The log data is recorded information including the operating status of the communication device and error messages. The server temporarily stores the received log data.

[0873] Input: Log data sent from communication devices

[0874] Output: Temporarily stored log data

[0875] Specific behavior:

[0876] The server listens for log data messages sent from a communication device using the UDP protocol. When a log data message is received, the server stores the message in a log file.

[0877] Step 2:

[0878] The server inputs the received log data into the generative AI model, which then analyzes the contents of the log data and extracts important error messages.

[0879] Input: Temporarily stored log data

[0880] Output: Extracted error message

[0881] Specific behavior:

[0882] The server passes the log data messages in text format to the generative AI model, which then uses natural language processing techniques to analyze the contents of the log data and extract important error messages.

[0883] Step 3:

[0884] The generative AI model identifies the cause of the failure based on the extracted error message, and infers the cause of the failure by referring to past failure response history and manufacturer manuals.

[0885] Input: The extracted error message

[0886] Output: Identified cause of failure

[0887] Specific behavior:

[0888] The generative AI model analyzes error messages such as "port error" contained in the log data and compares them with a past database. For example, if a "port error" is included, the generative AI model determines that there is a problem with the port.

[0889] Step 4:

[0890] The generative AI model proposes appropriate countermeasures based on the identified cause of the failure, and the proposals are written in natural language and provided to the user.

[0891] Input: Identified cause of failure

[0892] Output: Natural language suggestions for how to address the issue

[0893] Specific behavior:

[0894] The generative AI model extracts countermeasures such as "restart the port" or "replace the cable" from the history of past fault handling, and generates a suggestion text in natural language. The server notifies the user of this suggestion text.

[0895] Step 5:

[0896] The terminal uses an emotion engine to recognize the user's emotion, which analyzes the user's emotion and transmits the information to the server.

[0897] Input: User facial expressions and voice

[0898] Output: Analyzed user emotion information

[0899] Specific behavior:

[0900] The device analyzes the user's emotions from their facial expressions and voice. For example, if the user is very angry, the emotion engine sends that information to the server.

[0901] Step 6:

[0902] The server inputs the emotional information received from the emotion engine into the generative AI model and determines the priority of fault response.

[0903] Input: Analyzed user emotion information

[0904] Output: Prioritized fault response

[0905] Specific behavior:

[0906] The server inputs the information from the emotion engine into the generative AI model, which then sets the priority of fault response as the highest priority based on that information.

[0907] In this way, the system processes a series of steps from receiving log data to identifying the cause of the failure, proposing countermeasures, and determining priorities based on the user's emotions.

[0908] (Application example 2)

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

[0910] In order to respond quickly and appropriately when a network device fails, it is important to identify the cause of the failure and propose a solution. However, in conventional systems, identifying the cause of the failure and proposing a solution are often done manually, which takes time and makes it difficult to respond while taking the user's emotions into account. In particular, in situations where a user is very angry, for example, where a response that takes into account priorities according to emotions is required, conventional systems are insufficient in their response.

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

[0912] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data, a means for monitoring syslogs sent from the network devices in real time, a means for the generation AI to analyze the syslog and identify the cause of the failure, a means including an emotion engine that recognizes the user's emotions and determines the priority of the failure response based on the emotions, and a means for proposing a countermeasure based on the cause of the failure and the priority. This makes it possible to quickly identify the cause of the failure and propose an appropriate countermeasure according to the user's emotions.

[0913] The "past failure response history" is a record of responses made to past failures of network devices.

[0914] "Syslog" is a system log output by network devices, and contains information such as the device's operating status and error messages.

[0915] A "manufacturer's manual" is an instruction manual or technical document provided by the manufacturer of network equipment, which describes the specifications of the equipment and how to respond in the event of a malfunction.

[0916] "Generative AI" is a system that uses artificial intelligence technology to identify the cause of a failure from training data and suggest ways to deal with it.

[0917] "Network equipment" refers to hardware devices used to build and operate networks, including routers and switches.

[0918] "Monitoring in real time" means instantly monitoring the syslog sent from network devices and immediately detecting abnormalities or failures.

[0919] An "emotion engine" is a technology that recognizes a user's emotions and adjusts the system's behavior based on those emotions.

[0920] "Deciding priorities" means deciding which of multiple failure responses should be performed first.

[0921] "Proposing a solution" means presenting appropriate countermeasures, such as repairs or setting changes, for the identified cause of the failure.

[0922] As an embodiment of the present invention, a method for installing a security AI assistant system on a smartphone will be described.

[0923] System Programming

[0924] The security AI assistant system includes the following main components:

[0925] 1. Syslog monitoring module: Monitors syslogs sent from network devices in real time.

[0926] 2. Generative AI module: Analyzes syslog and identifies the cause of failure.

[0927] 3. Emotion engine module: Recognizes user emotions and prioritizes fault responses based on those emotions.

[0928] 4. Countermeasure suggestion module: Proposes appropriate countermeasures based on the cause of the failure and priority.

[0929] Hardware and Software

[0930] Hardware: Smartphone

[0931] software:

[0932] Python

[0933] syslog_parser library (syslog parsing)

[0934] ai_model library (generative AI models)

[0935] emotion_engine library (emotion engine)

[0936] Data processing and calculation

[0937] 1. Syslog monitoring: The server uses the syslog_parser library to monitor syslogs sent from network devices in real time, allowing for immediate detection of abnormalities and failures.

[0938] 2. Identifying the cause of the failure: The server uses the generation AI module to analyze the monitored syslog and identify the cause of the failure. The generation AI uses past failure response history and manufacturer manuals as learning data.

[0939] 3. Emotion Recognition: The device uses the emotion engine module to recognize the user's emotions. For example, if the user is very angry, it conveys that information to the generation AI.

[0940] 4. Priority determination: The server determines the priority of fault handling based on the recognized user sentiment.

[0941] 5. Proposing countermeasures: The server proposes appropriate countermeasures to the user in natural language based on the cause of the failure and priority.

[0942] Examples

[0943] For example, if a network switch breaks down and the syslog contains the error message "port error," the generative AI will determine that there is a problem with the port. Based on past troubleshooting history, it will suggest "restart the port" or "replace the cable." Furthermore, if the user is very angry, the emotion engine will communicate that information to the generative AI, making troubleshooting the top priority.

[0944] Examples of prompt statements

[0945] syslog: "port error detected on port 3"

[0946] user_emotion: "angry"

[0947] By inputting this prompt sentence into a generative AI model, the cause of the failure is identified and a solution is suggested.

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

[0949] Step 1:

[0950] The server uses the syslog_parser library to monitor syslogs sent from network devices in real time. The input is the syslog sent from the network device, and the output is the parsed syslog message. When the server receives a syslog message, it immediately analyzes it to detect any abnormalities or signs of failure.

[0951] Step 2:

[0952] The server uses a generation AI module to receive the analyzed syslog message as input and identify the cause of the failure. The generation AI uses past failure response history and manufacturer manuals as learning data. The output is the identified cause of the failure. The server analyzes error messages and warnings contained in the syslog message and identifies the cause of the failure.

[0953] Step 3:

[0954] The device recognizes the user's emotions using an emotion engine module. The input is the user's voice and facial expression data, and the output is the recognized emotional state of the user. The device captures the user's voice and facial expressions through a camera and microphone, and the emotion engine analyzes them to identify the user's emotional state.

[0955] Step 4:

[0956] The server receives the recognized emotional state of the user as input and determines the priority of the fault response. The output is the determined priority. If the user is very angry, the server conveys that information to the generation AI, which gives the top priority to the fault response.

[0957] Step 5:

[0958] The server uses a generation AI module to propose an appropriate solution based on the cause of the failure and the priority order. The input is the identified cause of the failure and the determined priority order, and the output is the proposed solution. The generation AI of the server refers to past failure response history and manufacturer manuals, and proposes the optimal solution to the user in natural language.

[0959] Step 6:

[0960] The user receives the suggested solution from the server and actually takes action. The input is the solution suggested by the server, and the output is the result of the solution that was actually taken. The user takes action such as rebooting the port or replacing the cable according to the instructions from the server.

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

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

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

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

[0965] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0978] "Example 1"

[0979] One embodiment of the present invention is a system including a generation AI that uses past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data. This system receives as input the syslogs output by network devices when a failure occurs, and identifies the cause of the failure based on the learning data. Furthermore, based on the identified cause of the failure, the system proposes an appropriate countermeasure in natural language.

[0980] "Example 2"

[0981] As a specific example, consider the case where a network switch breaks down. The syslog output by the switch when a failure occurs is input into the generation AI. The generation AI identifies the cause of the failure from the syslog based on the past failure response history and manufacturer manuals used as learning data. For example, if the syslog contains the error message "port error," the generation AI will determine that there is a problem with the port. Then, based on the past failure response history, it will suggest solutions in natural language, such as "restart the port" or "replace the cable."

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

[0983] "Example 1"

[0984] Step 1: Input the syslog output by the network device when a failure occurs into the generation AI.

[0985] Step 2: The generating AI identifies the cause of the failure from the syslog based on past failure response history and manufacturer manuals used as learning data.

[0986] Step 3: Based on the identified cause of the failure, an appropriate countermeasure is suggested in natural language.

[0987] "Example 2"

[0988] Step 1: When a network switch fails, the syslog output by the switch at the time of the failure is input into the generation AI.

[0989] Step 2: The generated AI analyzes the error message (e.g. "porterror") contained in the syslog and determines that there is a problem with the port.

[0990] Step 3: The generative AI suggests solutions in natural language, such as "restart the port" or "replace the cable," based on past fault response history.

[0991] Example 1

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

[0993] When a failure occurs in network equipment, it is necessary to quickly and accurately identify the cause and provide the user with an appropriate solution. However, with conventional systems, it takes time to identify the cause of the failure and propose a solution, which means the user cannot respond quickly. In addition, it is difficult to effectively use past failure response history and manufacturer manuals, which can reduce the efficiency of failure response.

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

[0995] In this invention, the server includes a means for receiving log data transmitted from a network device, a means for analyzing the received log data and extracting an error message, a means for inputting the extracted error message to a generative AI model, a means for the generative AI model to use past failure response history, log data, and a manufacturer manual as learning data to identify the cause of the failure, a means for the generative AI model to generate an appropriate countermeasure in natural language based on the identified cause of the failure, and a means for notifying a user of the generated countermeasure. This makes it possible to quickly and accurately identify the cause of a failure in a network device and provide the user with an appropriate countermeasure.

[0996] A "network device" is a hardware device for conducting data communications, and includes routers, switches, firewalls, etc.

[0997] "Log data" refers to recorded information generated by network devices during operation, and includes error messages and warning messages.

[0998] An "error message" is warning information that is output when a network device detects a failure or abnormality.

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

[1000] "Failure response history" refers to data that records past failures and how they were handled.

[1001] A "manufacturer's manual" is a document that includes operating procedures and troubleshooting guides provided by the manufacturer of network equipment.

[1002] "Natural language" refers to the language used by humans on a daily basis, and is the form of response output by generative AI models.

[1003] "User" means an individual or organization that manages and operates network equipment.

[1004] A "notification" is an action in which the server conveys information to the user, and is carried out via email or the dashboard.

[1005] The present invention is a system for quickly and accurately identifying the cause of a fault in a network device and providing a user with an appropriate solution. A specific embodiment of this system will be described below.

[1006] Hardware and software used

[1007] Hardware: Server (e.g. general-purpose server)

[1008] Software: Generative AI models (e.g., general generative AI models), syslog analysis tools (e.g., general log analysis tools)

[1009] System Configuration

[1010] 1. The server receives log data sent from the network device. Specifically, the server functions as a syslog server and receives log data from the network device on port 514.

[1011] 2. The server analyzes the received log data and extracts error messages. Specifically, the server uses a log analysis tool to extract error messages and warning messages from the log data.

[1012] 3. The server prepares the extracted error message as data to be input to the generative AI model. Specifically, it formats the error message in text format and launches the generative AI model.

[1013] 4. The server inputs the error message into the generative AI model to identify the cause of the failure. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data, and estimates the cause of the failure based on the error message.

[1014] 5. The server uses a generative AI model to generate an appropriate solution based on the identified cause of the failure. The generative AI model proposes the solution in natural language.

[1015] 6. The server notifies the user of the generated solution. Specifically, the server provides the solution to the user via email or dashboard.

[1016] Examples

[1017] 1. The network device outputs log data containing the error message "Interface down."

[1018] 2. The server receives this log data and extracts the error message "Interface down."

[1019] 3. The server inputs the error message "Interface down" into the generative AI model.

[1020] 4. The generative AI model refers to past fault response history and manufacturer manuals to identify "broken cable" or "port failure" as the cause of "Interface down."

[1021] 5. The generative AI model then uses natural language to suggest solutions such as "check the cable and replace if necessary" or "restart the port."

[1022] 6. The server notifies the user of this solution.

[1023] Examples of prompt statements

[1024] "The log data from a network device contains the error message 'Interface down'. What is the cause of this error message and how can I resolve it?"

[1025] In this way, the server realizes a system that identifies the cause of a failure in a network device and provides the user with an appropriate solution.

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

[1027] Step 1:

[1028] The server receives log data sent from the network device. Specifically, the server functions as a syslog server and receives log data from the network device on port 514. The input is the log data from the network device, and the output is the received log data.

[1029] Step 2:

[1030] The server analyzes the received log data and extracts error messages. Specifically, it uses a log analysis tool to filter error messages and warning messages from the log data. The input is the received log data and the output is the extracted error messages.

[1031] Step 3:

[1032] The server prepares the extracted error message as data to be input to the generative AI model. Specifically, it formats the error message in text format and launches the generative AI model. The input is the extracted error message, and the output is the text data to be input to the generative AI model.

[1033] Step 4:

[1034] The server inputs error messages into the generative AI model and identifies the cause of the failure. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data, and estimates the cause of the failure based on the error message. The input is the text data input into the generative AI model, and the output is the identified cause of the failure.

[1035] Step 5:

[1036] The server uses a generative AI model to generate an appropriate solution based on the identified cause of the failure. The generative AI model proposes a solution in natural language. The input is the identified cause of the failure, and the output is the generated solution.

[1037] Step 6:

[1038] The server notifies the user of the generated solution. Specifically, the solution is provided to the user via email or a dashboard. The input is the generated solution, and the output is the solution notified to the user.

[1039] (Application example 1)

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

[1041] Robots operating in factories need to be diagnosed and repaired quickly and accurately when they break down. However, with conventional systems, it was difficult to identify the cause of the failure or propose an appropriate solution, and repairs often took a long time. There was also the problem that a technician with specialized knowledge was always needed, which increased costs. To solve these issues, a system was needed that could quickly identify the cause of the failure and automatically propose an appropriate solution.

[1042] The identification process by the identification processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means. In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslog output by a network device when a failure occurs, and manufacturer manuals as learning data, a means for diagnosing a failure and providing repair support for a robot operating in a factory, a means for analyzing the syslog output by a robot when a failure occurs and identifying the cause of the failure, and a means for proposing an appropriate countermeasure in natural language based on the identified cause of the failure. This makes it possible to quickly identify the cause of the failure and automatically propose an appropriate countermeasure.

[1043] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[1044] The "syslog output by a network device when a failure occurs" is log data that is generated when a network device fails, and includes detailed information about the failure.

[1045] "Manufacturer's Manual" means an instruction manual or technical documentation provided by a product manufacturer that includes information on how to use the product and troubleshooting.

[1046] "Generative AI" is artificial intelligence that generates new information based on learning data, identifying the cause of failures and proposing countermeasures.

[1047] A "factory robot" is an automated machine designed to perform tasks in a factory.

[1048] "Fault diagnosis" is the analytical process for determining the cause of a fault.

[1049] "Repair assistance" refers to the provision of information and assistance to assist in the repair of broken equipment.

[1050] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[1051] "Analysis" is the process of examining data in detail to understand its meaning and structure.

[1052] "Solutions" are specific actions or steps to be taken in response to an identified problem.

[1053] In order to implement the present invention, the following system configuration and program are required.

[1054] The server contains a generative AI model that uses past fault response history, syslogs output by network devices when a fault occurs, and manufacturer manuals as learning data. This generative AI model analyzes the syslogs output by the robot when a fault occurs and identifies the cause of the fault. It also proposes appropriate countermeasures in natural language based on the identified cause of the fault.

[1055] Specifically, the server performs the following process.

[1056] 1. Data collection and analysis:

[1057] The server receives syslog data sent from robots operating in the factory. The received syslog data is parsed using the syslog_parser module. This analysis extracts detailed information about the failure.

[1058] 2. Identifying the cause of the failure:

[1059] The analyzed data is input to the generative AI model, which has learned from past fault response history and manufacturer manuals, and identifies the cause of the fault based on this. The ai_model module is used for this identification.

[1060] 3. Suggested solutions:

[1061] Based on the identified fault causes, the generative AI model generates appropriate countermeasures, which are generated using the ai_model module. The generated countermeasures are then converted into natural language using the natural_language_processor module.

[1062] 4. Notice to Users:

[1063] The solution converted into natural language is notified to the user, so that the user can quickly take the appropriate solution.

[1064] As a concrete example, by inputting the following prompt sentence into the generative AI model, the cause of the failure and how to deal with it can be identified.

[1065] Prompt text: "2023-10-01 12:00:00 ERROR: Motor failure in section A"

[1066] Using this prompt as input, the generative AI model produces the following output:

[1067] Output: "A motor failure has occurred in section A. Please attempt to restart the motor based on past failure history and manufacturer manual. If restarting is unsuccessful, the motor will need to be replaced."

[1068] In this way, the server can quickly identify the cause of a failure and automatically suggest appropriate countermeasures, which will efficiently diagnose failures and provide repair support for robots operating in factories.

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

[1070] Step 1:

[1071] The server receives syslog data sent from robots operating in the factory. The input is the syslog data from the robot, and the output is the received syslog data. This data includes detailed information such as the time when the failure occurred and error messages.

[1072] Step 2:

[1073] The server parses the received syslog data using the syslog_parser module. The input is the received syslog data, and the output is the parsed failure information. This parsing extracts detailed information such as error messages and the location of the failure.

[1074] Step 3:

[1075] The server inputs the analyzed failure information into the generative AI model. The input is the analyzed failure information, and the output is the identified cause of the failure. The generative AI model learns from past failure response history and manufacturer manuals, and identifies the cause of the failure based on this.

[1076] Step 4:

[1077] The server uses a generative AI model to generate appropriate countermeasures based on the identified cause of the failure. The input is the identified cause of the failure, and the output is the generated countermeasure. The countermeasure is generated based on the history of past failure responses and the manufacturer's manual.

[1078] Step 5:

[1079] The server converts the generated action into natural language using the natural_language_processor module. The input is the generated action and the output is the action converted into natural language. This conversion provides the action in a form that is easy for the user to understand.

[1080] Step 6:

[1081] The server notifies the user of the solution converted into natural language. The input is the solution converted into natural language, and the output is a notification to the user. This allows the user to quickly take appropriate measures.

[1082] Example 2

[1083] Next, a second embodiment of the second form will be described. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal".

[1084] When network equipment fails, there is a need to quickly and accurately identify the cause of the failure and propose appropriate countermeasures. However, with conventional systems, it takes time to identify the cause of the failure and propose countermeasures, and engineers with specialized knowledge are required, making it difficult to respond to failures efficiently.

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

[1086] In this invention, the server includes a means for receiving log data transmitted from a network device, a means for analyzing the log data and extracting an error message, a means for inputting the extracted error message into a generative AI model and identifying the cause of a failure, a means for proposing a countermeasure based on the cause of the failure by the generative AI model, and a means for notifying a user of the proposed countermeasure. This makes it possible to quickly and accurately identify the cause of a failure and propose an appropriate countermeasure.

[1087] A "network device" is a hardware device for data communication, including routers and switches.

[1088] "Log data" refers to recorded information generated by a network device during operation, and includes error messages and event information.

[1089] An "error message" is a message that is output by a network device when it detects an abnormality, and contains information that is useful for identifying the cause of the failure.

[1090] A "generative AI model" is a model that is trained using artificial intelligence technology to perform specific tasks, such as identifying the cause of a failure and proposing countermeasures based on past data and technical documentation.

[1091] The "cause of failure" is a factor that prevents a network device from operating normally, and is identified from error messages and log data.

[1092] A "remedy" is a remedial measure taken to address the identified cause of the failure, such as rebooting the port or replacing the cable.

[1093] "User" means a person or organization that manages and operates network equipment and is the recipient of troubleshooting proposals.

[1094] The present invention is a system for quickly and accurately identifying the cause of a failure when a network device fails and proposing an appropriate countermeasure. A specific embodiment of this system will be described below.

[1095] The server receives log data sent from the network devices. The log data includes the operating status of the network devices and error messages. The server analyzes the received log data and extracts error messages. This analysis includes checking the format of the data and extracting error messages.

[1096] Next, the server inputs the extracted error message into the generative AI model. The generative AI model uses past fault response history and technical documents as learning data and identifies the cause of the fault from the error message. For example, if the error message contains "port error," the generative AI model will determine that there is a problem with the port.

[1097] After the cause of the failure is identified, the server uses a generative AI model to suggest appropriate countermeasures. The suggestions are generated based on past failure response history and technical documentation. For example, countermeasures such as "restart the port" or "replace the cable" are suggested.

[1098] Finally, the server notifies the user of the proposed solution. Possible notification methods include email and display on the dashboard. This allows the user to quickly identify the cause of the failure and implement the appropriate solution.

[1099] To illustrate, consider the following scenario:

[1100] The server receives log data "2023-10-01 12:00:00 port error detected on port 3" from the network device.

[1101] The server analyzes this log data and extracts the error message "port error."

[1102] The server inputs the extracted error messages into a generative AI model to identify the cause of the failure.

[1103] The generative AI model determines that there is a problem with the port and suggests restarting the port or replacing the cable.

[1104] The server will notify the user of the proposal via email.

[1105] Example prompt:

[1106] Syslog data: "2023-10-01 12:00:00 port error detected on port 3"

[1107] Prompt for generative AI model: "Please identify the cause of the failure from this syslog data and suggest appropriate countermeasures."

[1108] In this way, the server can receive log data, analyze it, and use a generative AI model to identify the cause of the failure and notify the user of the appropriate course of action.

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

[1110] Step 1:

[1111] The server receives the log data transmitted from the network device.

[1112] Specifically, the server listens to a network port and receives log data in real time, which is then temporarily stored.

[1113] Input: Log data from network devices

[1114] Output: Temporarily saved log data

[1115] Step 2:

[1116] The server analyzes the received log data and extracts error messages.

[1117] Specifically, the server checks the format of the log data and extracts the part containing the error message. Regular expressions and pattern matching techniques are used for analysis.

[1118] Input: Temporarily saved log data

[1119] Output: Extracted error message

[1120] Step 3:

[1121] The server inputs the extracted error messages into a generative AI model to identify the cause of the failure.

[1122] Specifically, the server inputs the error message as a prompt to the generative AI model, which then identifies the cause of the failure based on past failure response history and technical documentation.

[1123] Input: The extracted error message

[1124] Output: Identified cause of failure

[1125] Step 4:

[1126] The server then suggests countermeasures based on the causes of the failure identified using the generative AI model.

[1127] Specifically, the server generates appropriate countermeasures based on the cause of the failure obtained from the generative AI model. Countermeasures are proposed based on past failure response history and technical documentation.

[1128] Input: Identified cause of failure

[1129] Output: Suggested action to be taken

[1130] Step 5:

[1131] The server will notify the user of the suggested course of action.

[1132] Specifically, the server retrieves the user's contact information and sends the suggestions via email or dashboard.

[1133] Input: Proposed action

[1134] Output:Notification to the user

[1135] In this way, the server can receive log data, analyze it, and use a generative AI model to identify the cause of the failure and notify the user of the appropriate course of action.

[1136] (Application example 2)

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

[1138] When a factory robot breaks down, it is necessary to quickly and accurately identify the cause of the failure and propose an appropriate solution. However, with conventional systems, it takes time to identify the cause of the failure and propose a solution, which prolongs factory downtime. In addition, there is also the issue of the constant need for engineers with specialized knowledge, which is costly.

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

[1140] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, log data output by the network device when a failure occurs, and the manufacturer's manual as learning data, a means for analyzing in real time the log data generated when the factory robot breaks down, a means for proposing a specific countermeasure based on the past failure response history and the manufacturer's manual, and a means for outputting the generated cause of the failure and the countermeasure in natural language. This enables a quick and accurate response when the factory robot breaks down.

[1141] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[1142] The "log data output by a network device when a failure occurs" is data that includes error messages and status information that are generated when a network device fails.

[1143] A "manufacturer's manual" is a document provided by a manufacturer regarding how to use and troubleshoot a device.

[1144] "Generative AI" is artificial intelligence that learns from past data and identifies the cause of failures and generates countermeasures based on new data.

[1145] A "factory robot" is a mechanical device used to perform automated tasks in a factory.

[1146] "Real-time analysis" means analyzing data as soon as it is generated.

[1147] "Providing suggestions in natural language" means presenting solutions in terms that are easy for humans to understand.

[1148] A "cause of failure" is a factor that causes equipment to not operate normally.

[1149] A "measure" is a method for correcting a malfunction and returning the equipment to a normal state.

[1150] The system for carrying out the present invention is for quickly and accurately dealing with the breakdown of a factory robot. A specific embodiment of the system is described below.

[1151] System Configuration

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

[1153] 1. Server: A computer system for running the generative AI model.

[1154] 2. Factory Robot: A mechanical device that performs automated tasks in a factory.

[1155] 3. Network equipment: Equipment for communication between the robot and the server.

[1156] Hardware and Software Used

[1157] Hardware: Factory robots, servers, network equipment

[1158] Software: Python, OpenAI API

[1159] Data processing and calculation

[1160] Server Processing

[1161] 1. Log data collection: The server collects log data generated when a factory robot breaks down.

[1162] 2. Prompt sentence generation: The server generates prompt sentences to be input into the generative AI model based on the collected log data.

[1163] 3. Analysis by generative AI: The server uses the OpenAI API to input prompt text into the generative AI model to generate the cause of the failure and a solution.

[1164] 4. Output of results: The server outputs the generated cause of the fault and how to deal with it in natural language and presents it to the user.

[1165] Examples

[1166] For example, if a factory robot generates log data containing the error message "port error on port 3," the server inputs the following prompt sentence into the generative AI model:

[1167] Examples of prompt statements

[1168] Please analyze the following log data and suggest the cause of the failure and how to deal with it.

[1169] Log data: 2023-10-01 12:00:00 ERROR: port error on port 3

[1170] Based on this prompt, the generative AI model determines that "there is a problem with port 3" and suggests solutions such as "restarting the port" or "replacing the cable."

[1171] effect

[1172] This system enables a rapid and accurate response when a factory robot breaks down, minimizing factory downtime. It also contributes to cost reduction because engineers with specialized knowledge are not always required.

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

[1174] Step 1:

[1175] The server collects log data that is generated when a factory robot breaks down. The log data includes error messages and status information. This log data is input. The server receives the log data via the network and stores it in a database.

[1176] Step 2:

[1177] The server generates a prompt sentence to be input to the generative AI model based on the collected log data. The input data for generating this prompt sentence is the log data collected in step 1. The server analyzes the log data and creates a prompt sentence in an appropriate format. For example, the format is "Analyze the following log data and propose the cause of the failure and how to deal with it. Log data: 2023-10-01 12:00:00 ERROR: port error on port 3."

[1178] Step 3:

[1179] The server inputs the generated prompt sentence into the generative AI model using the OpenAI API. This prompt sentence becomes the input. The generative AI model uses past fault response history and manufacturer manuals as learning data, and generates the cause of the fault and a solution based on the prompt sentence. The generated cause of the fault and a solution become the output.

[1180] Step 4:

[1181] The server outputs the cause of the failure and the countermeasure obtained from the generative AI model in natural language and presents it to the user. This output is displayed in a format that is easy for the user to understand. For example, it could be in the format of "There is a problem with port 3, so please restart the port." The server displays this information through a user interface.

[1182] Step 5:

[1183] The user repairs the factory robot based on the solution presented by the server. The user performs specific repair work according to the instructions from the server, such as restarting a port or replacing a cable. After the user completes the repair, he or she reports the completion of the repair to the server.

[1184] In this way, a rapid and accurate response can be made when a factory robot breaks down.

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

[1186] "Example 1"

[1187] As one embodiment of the present invention, a system including an emotion engine that recognizes the emotions of a user is provided. This system includes a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data. Furthermore, this generation AI includes an emotion engine that recognizes the emotions of a user. This emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and language, and adjusts the identification of the cause of the failure and the proposal of a countermeasure based on the emotion. For example, if the user is angry, the emotion engine conveys that information to the generation AI, and the generation AI proposes a more rapid countermeasure.

[1188] "Example 2"

[1189] As another embodiment, a system is provided in which an emotion engine determines the priority of fault handling based on the emotion of a user. This system is a further development of the system described in claim 4. Specifically, the emotion engine recognizes the emotion of a user and determines the priority of fault handling based on the emotion. For example, if a user is very angry, the emotion engine conveys that information to the generation AI, and the generation AI gives top priority to that fault handling. This enables more appropriate fault handling according to the emotion of the user.

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

[1191] "Example 1"

[1192] Step 1: Recognize the user's emotions The emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and choice of words.

[1193] Step 2: The emotion engine communicates the recognized user emotion to the generative AI.

[1194] Step 3: The generation AI adjusts the identification of the cause of the failure and the proposed solution based on the user's emotions. For example, if the user is angry, the generation AI will suggest a quicker solution. "Example 2"

[1195] Step 1: Recognize the user's emotions The emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and choice of words.

[1196] Step 2: The emotion engine communicates the recognized user emotion to the generative AI.

[1197] Step 3: The generative AI prioritizes the fault response based on the user's emotions. For example, if the user is very angry, the generative AI gives top priority to that fault response.

[1198] Example 1

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

[1200] Conventional troubleshooting systems often fail to quickly and accurately identify the cause of a malfunction or propose a solution, and they have a particular problem in that it is difficult to respond to the user's emotions. This leads to a decrease in user satisfaction and a deterioration in the efficiency of troubleshooting.

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

[1202] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using the past failure response history, the log data output by the information processing device when a failure occurs, and technical documents as learning data, a means for receiving the log data output by the information processing device when a failure occurs, a means including an emotion engine that recognizes the user's emotion, and a means for adjusting the proposed countermeasure based on the user's emotion information. This makes it possible to quickly and accurately identify the cause of the failure and propose an appropriate countermeasure according to the user's emotion.

[1203] The "past failure response history" is data that records the response methods and results of failures that have occurred in the past.

[1204] "Log data" refers to data that records events and error messages that are generated by an information processing device during its operation.

[1205] "Technical documentation" refers to documents that contain product specifications, operating instructions, troubleshooting guides, etc.

[1206] "Generative AI" is an artificial intelligence that uses learning data to identify the cause of a failure and suggest ways to deal with it.

[1207] The "emotion engine" is a system that recognizes emotions from the user's tone of voice, facial expressions, choice of words, etc.

[1208] "Information processing device" is a general term for devices that input, process, and output data.

[1209] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[1210] The present invention is a system that analyzes log data output when a failure occurs in a network device, identifies the cause of the failure based on past failure response history and technical documents, and proposes appropriate countermeasures.Furthermore, it has a function to recognize the user's emotions and propose countermeasures according to those emotions.

[1211] System Configuration

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

[1213] 1. Server

[1214] The server receives and analyzes the log data sent from the network devices. Specifically, the server monitors the log data in real time and saves the received data in a log file.

[1215] The server is equipped with a generation AI that uses past fault response history and technical documents as learning data. The generation AI analyzes the log data and identifies the cause of the fault.

[1216] 2. Terminal

[1217] The device is responsible for inputting the user's tone of voice, facial expressions, and vocabulary into the emotion engine. Specifically, the device uses a microphone and camera to capture the user's voice and video and transmits them to the emotion engine.

[1218] The terminal displays the solution sent from the server to the user.

[1219] 3. Emotion Engine

[1220] The emotion engine recognizes emotions from the user's tone of voice, facial expressions, vocabulary, etc. The emotion engine performs voice and image analysis to identify the user's emotional state (e.g. anger, sadness, joy).

[1221] The emotion engine conveys the recognized emotional information to the generative AI.

[1222] System Operation

[1223] 1. Data Entry

[1224] The server receives log data sent from the network device. For example, when the network device outputs log data of "link down", the server receives this information and stores it in a log file.

[1225] The device captures the user's tone of voice and facial expressions and sends them to the emotion engine.

[1226] 2. Data Processing

[1227] The server analyzes the received log data. Specifically, the server parses the contents of the log data and extracts error messages and warning messages.

[1228] The generation AI identifies the cause of the failure based on the analysis results and learning data. For example, the generation AI refers to the response history of past link downs and technical documentation and identifies the cause of the failure as a "broken cable."

[1229] The emotion engine recognizes "anger" from the tone of the user's voice and conveys that information to the generation AI.

[1230] 3. Proposal for solutions

[1231] The generation AI generates appropriate countermeasures in natural language based on the identified cause of the failure and the user's emotional information. For example, the generation AI refers to standard countermeasures for the cause of the failure and adjusts the proposed content according to the user's emotional state.

[1232] The server transmits the generated solution to the terminal, and the terminal displays the content of the solution to the user.

[1233] Examples

[1234] For example, when a network device outputs log data indicating "link down," the process proceeds as follows.

[1235] 1. The server receives the "link down" log data and saves it in a log file.

[1236] 2. The device captures the user's tone of voice and facial expressions and sends them to the emotion engine.

[1237] 3. The server parses the contents of the log data and extracts the "link down" error message.

[1238] 4. The generation AI refers to the response history of past link-downs and technical documentation, and identifies the cause of the failure as a "broken cable."

[1239] 5. The emotion engine recognizes "anger" from the tone of the user's voice and conveys that information to the generation AI.

[1240] 6. Based on the cause of the failure and the user's emotional information of "anger," the generative AI will suggest "replacing the cable immediately."

[1241] 7. The server sends the generated solution to the terminal, and the terminal displays it to the user.

[1242] Examples of prompt statements

[1243] "The network device has output log data indicating a link down. Please identify the cause of the failure based on past support history and technical documentation, and propose a quick response method in case the user is angry."

[1244] In this way, the system makes it possible to efficiently respond to network device failures and provides appropriate countermeasures according to the user's emotions.

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

[1246] Step 1:

[1247] The server receives log data sent from the network devices. Specifically, the server monitors the log data in real time and saves the received data in a log file. The input is the log data from the network devices, and the output is the saved log file.

[1248] Step 2:

[1249] The terminal inputs the user's tone of voice, facial expressions, and language into the emotion engine. Specifically, the terminal uses a microphone and camera mounted on the terminal to capture the user's voice and video and transmits them to the emotion engine. The input is the user's voice and video, and the output is the data transmitted to the emotion engine.

[1250] Step 3:

[1251] The server analyzes the received log data. Specifically, the server parses the contents of the log data and extracts error and warning messages. The input is the saved log file, and the output is the extracted error and warning messages.

[1252] Step 4:

[1253] The generation AI identifies the cause of the failure based on the analysis results and learning data. Specifically, the generation AI refers to past failure response history and technical documents to search for similar failure patterns. The inputs are the extracted error and warning messages and learning data, and the output is the identified cause of the failure.

[1254] Step 5:

[1255] The emotion engine recognizes the user's emotions and conveys that information to the generative AI. Specifically, the emotion engine performs voice and image analysis to identify the user's emotional state (e.g., anger, sadness, joy). The input is the user's voice and video, and the output is the recognized emotional information.

[1256] Step 6:

[1257] The generation AI generates appropriate countermeasures in natural language based on the identified cause of the failure and the user's emotional information. Specifically, the generation AI refers to standard countermeasures for the cause of the failure and adjusts the proposed content according to the user's emotional state. The input is the identified cause of the failure and the recognized emotional information, and the output is the generated countermeasure.

[1258] Step 7:

[1259] The server transmits the generated solution to the terminal, and the terminal displays the content to the user. Specifically, the server transmits the generated solution to the terminal, and the terminal displays the content on the screen. The input is the generated solution, and the output is the solution displayed to the user.

[1260] (Application example 1)

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

[1262] Conventional fault response systems often fail to quickly and accurately identify the cause of a fault or propose countermeasures, making it particularly difficult to respond flexibly to the user's emotions. In addition, when responding to faults in robots operating in factories, it is necessary to respond in a way that takes into account the emotions of the operator, but there was a lack of technology to achieve this.

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

[1264] In this invention, the server includes a means including a generation AI that uses past failure response history, log data output by the information processing device when a failure occurs, and technical documents as learning data to identify the cause of the failure and propose a countermeasure in natural language, a means for the generation AI to identify the cause of the failure from the log data output by the information processing device when a failure occurs, a means to propose a countermeasure based on the cause of the failure, a means including an emotion recognition engine that recognizes the user's emotions, and a means for the emotion recognition engine to recognize the user's emotions from the user's tone of voice, facial expression, and wording, and to adjust the identification of the cause of the failure and the proposal of the countermeasure based on the emotions. This makes it possible to quickly and accurately identify the cause of the failure and propose a flexible countermeasure according to the user's emotions.

[1265] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[1266] "Log data" is a record of events and errors generated by an information processing device during operation.

[1267] "Technical documentation" refers to documents that describe product or system specifications, operation methods, troubleshooting, etc.

[1268] "Generative AI" is artificial intelligence that generates new information based on training data and performs specific tasks.

[1269] An "emotion recognition engine" is a system that analyzes and recognizes emotions from a user's tone of voice, facial expressions, choice of words, etc.

[1270] "Identifying the cause of a failure" means clarifying the fundamental cause of a failure that has occurred.

[1271] "Proposing a solution" means presenting appropriate repair or response procedures based on the identified cause of the failure.

[1272] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[1273] "A user's tone of voice" refers to changes in pitch and intensity of the voice that indicate the speaker's emotions and intent.

[1274] "Facial expressions" are emotions and reactions shown by the movement of facial muscles.

[1275] "Language" refers to the words and expressions a speaker chooses to use, and reflects the speaker's feelings and attitudes.

[1276] A system for implementing the present invention includes an application called "Smart Maintenance Assistant" that is installed on a robot that operates in a factory. A specific embodiment of this system will be described below.

[1277] Hardware and Software Used

[1278] Hardware: Factory robots, microphones, cameras

[1279] Software: syslog parsing library (syslog_parser), emotion recognition library (emotion_recognition), generative AI model (ai_model)

[1280] System Configuration

[1281] 1. Identifying the cause of the failure:

[1282] The server analyzes in real time the log data that is output when the robot breaks down. Using a syslog analysis library, the server identifies the cause of the failure from the log data. Specifically, the server analyzes the log data based on past failure response history and technical documentation to clarify the root cause of the failure.

[1283] 2. Suggested solutions:

[1284] The server uses a generative AI model to propose appropriate countermeasures based on the identified cause of the failure. This generative AI model uses past failure response history and technical documents as learning data and proposes countermeasures in natural language.

[1285] 3. Emotion recognition:

[1286] The server uses emotion recognition libraries to analyze the user's tone of voice, facial expressions, and phrasing. Using microphones and cameras, it recognizes the user's emotions in real time. For example, if the user is angry, the emotion recognition engine passes that information to the generative AI model, which then trains it to suggest quick ways to deal with the situation.

[1287] Examples

[1288] For example, if a robot breaks down and "error code 123" is recorded in the log data, the server uses a syslog analysis library to identify the cause of "error code 123." It then uses a generative AI model to suggest countermeasures, such as "This is due to the motor overheating. Please check the cooling system."

[1289] Furthermore, if the user is angry when receiving this information, the emotion recognition engine will communicate that information to the generative AI model, suggesting faster and more specific ways to respond.

[1290] Examples of prompt statements

[1291] "Error code 123 has occurred. Please identify the cause of the failure based on past troubleshooting history and technical documentation, and propose an appropriate solution."

[1292] In this way, the smart maintenance assistant can streamline response to robot breakdowns in factories and enable flexible responses based on the emotions of operators.

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

[1294] Step 1:

[1295] The server receives log data output when a robot breaks down. The log data is sent in real time from the information processing device. The server analyzes this log data using a syslog analysis library (syslog_parser). Specifically, it extracts error codes and warning messages from the log data and compares them with past failure response history and technical documentation. This provides basic data for identifying the cause of the failure.

[1296] Input: Log data sent from the robot

[1297] Output: Extracted error codes and warning messages.

[1298] Step 2:

[1299] The server uses a syslog analysis library to analyze the extracted error codes and warning messages, and identifies the cause of the failure. It refers to past failure response history and technical documentation, and estimates the cause of the failure based on the response methods used when similar errors occurred. It uses a generative AI model (ai_model) to perform data calculations to identify the cause of the failure.

[1300] Input: Extracted error code or warning message

[1301] Output: Identified cause of failure

[1302] Step 3:

[1303] The server uses a generative AI model to propose an appropriate solution based on the identified cause of the failure. The generative AI model uses past failure response history and technical documents as learning data to generate a solution in natural language. The generated solution is presented to the user in natural language.

[1304] Input: Identified cause of failure

[1305] Output: Natural language generated instructions for action

[1306] Step 4:

[1307] The server uses an emotion recognition library (emotion_recognition) to analyze the user's tone of voice, facial expressions, and vocabulary. It uses a microphone and camera to recognize the user's emotions in real time. The emotion recognition engine conveys the user's emotion data to the generative AI model.

[1308] Input: The user's tone of voice, facial expressions, and language

[1309] Output: Recognized user emotion data

[1310] Step 5:

[1311] The server adjusts the generative AI model based on the user's emotion data obtained from the emotion recognition engine. For example, if the user is angry, the generative AI model is adjusted to suggest a quick solution. This makes it possible to propose flexible solutions according to the user's emotions.

[1312] Input: Recognized user emotion data

[1313] Output: Tailored action suggestions

[1314] Step 6:

[1315] The server presents the adjusted solution to the user. The user confirms the solution presented in natural language and takes the necessary action. This enables the cause of the failure to be identified quickly and accurately, and flexible solutions that correspond to the user's feelings are proposed.

[1316] Input: Adjusted response

[1317] Output: The action suggested to the user

[1318] Example 2

[1319] Next, a second embodiment of the second form will be described. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal".

[1320] In conventional fault response systems, it was difficult to identify the cause of a network device fault and propose an appropriate method of dealing with the fault. In addition, it was not possible to determine the priority of fault response based on the user's emotions, and it was not possible to improve user satisfaction. This caused the problem that it was difficult to respond efficiently in the field where a prompt and appropriate fault response was required.

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

[1322] In this invention, the server includes: a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, log data output by the communication device when a failure occurs, and a manufacturer's manual as learning data; a means for the generation AI to identify the cause of the failure from the log data output by the communication device when a failure occurs, a means to propose a countermeasure based on the cause of the failure, a means including an emotion engine that recognizes the user's emotion and determines the priority of the failure response based on the emotion, and a means for the emotion engine to convey the user's emotion information to the generation AI and for the generation AI to determine the priority of the failure response based on the information. This enables a quick and appropriate failure response, and improves user satisfaction by determining the priority according to the user's emotion.

[1323] The "past failure response history" is data on the response methods and results recorded when a failure occurs in a communication device.

[1324] "Log data" refers to recorded information including error and warning messages generated by a communication device during operation.

[1325] A "manufacturer's manual" is a document that describes operating procedures and troubleshooting methods provided by the manufacturer of a communications device.

[1326] "Generative AI" is an artificial intelligence that uses past fault response history, log data, and manufacturer manuals as learning data to identify the cause of a fault and suggest countermeasures in natural language.

[1327] The "emotion engine" is a system that recognizes the user's emotions and determines the priority of troubleshooting based on those emotions.

[1328] "Communications equipment" refers to hardware devices used for data communication, such as network switches and routers.

[1329] "Natural language" refers to the language used by humans on a daily basis, and is the form of expression for the solutions proposed by generative AI.

[1330] "Priority" refers to the order in which one of multiple failure responses should be performed first.

[1331] The present invention is a system for identifying the cause of a failure in a communication device and proposing an appropriate countermeasure. The system is composed of a server, a terminal, and a user.

[1332] The server receives log data sent from the communication device and inputs it into the generative AI model. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data and analyzes the contents of the log data. For example, if the log data contains an error message "port error," the generative AI model determines that there is a problem with the port.

[1333] After identifying the cause of the failure, the generative AI model proposes appropriate countermeasures in natural language based on past failure response history. Specifically, it suggests countermeasures such as "restarting the port" or "replacing the cable." The server notifies the user of this suggested text.

[1334] The device is equipped with an emotion engine to recognize the user's emotions. The emotion engine analyzes emotions from the user's facial expressions and voice and sends the information to the server. The server inputs the emotion information received from the emotion engine into the generative AI model and determines the priority of fault response. For example, if the user is very angry, the emotion engine conveys that information to the generative AI model, and the generative AI model gives top priority to the fault response.

[1335] As a concrete example, consider a case where a network switch breaks down and an error message "port error" is output to the log data. In this case, the generative AI model receives the following prompt sentence as input:

[1336] Example prompt:

[1337] The error message "port error" was displayed in the log data of the network switch. What is the cause of the error and how can I solve it?

[1338] Based on this prompt, the generative AI model generates the following output:

[1339] Example output of a generative AI model:

[1340] The cause of the failure may be a problem with the port. To solve the problem, try the following steps:

[1341] 1. Restart the port.

[1342] 2. Try replacing the cable.

[1343] 3. If the problem persists, refer to the manufacturer's manual for further diagnosis.

[1344] In this way, the system processes a series of steps from receiving log data to identifying the cause of the failure, proposing countermeasures, and determining priorities based on the user's emotions. This enables quick and appropriate response to failures, and by determining priorities according to the user's emotions, it is possible to improve user satisfaction.

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

[1346] Step 1:

[1347] The server receives log data transmitted from the communication device. The log data is recorded information including the operating status of the communication device and error messages. The server temporarily stores the received log data.

[1348] Input: Log data sent from communication devices

[1349] Output: Temporarily stored log data

[1350] Specific behavior:

[1351] The server listens for log data messages sent from a communication device using the UDP protocol. When a log data message is received, the server stores the message in a log file.

[1352] Step 2:

[1353] The server inputs the received log data into the generative AI model, which then analyzes the contents of the log data and extracts important error messages.

[1354] Input: Temporarily stored log data

[1355] Output: Extracted error message

[1356] Specific behavior:

[1357] The server passes the log data messages in text format to the generative AI model, which then uses natural language processing techniques to analyze the contents of the log data and extract important error messages.

[1358] Step 3:

[1359] The generative AI model identifies the cause of the failure based on the extracted error message, and infers the cause of the failure by referring to past failure response history and manufacturer manuals.

[1360] Input: The extracted error message

[1361] Output: Identified cause of failure

[1362] Specific behavior:

[1363] The generative AI model analyzes error messages such as "port error" contained in the log data and compares them with a past database. For example, if a "port error" is included, the generative AI model determines that there is a problem with the port.

[1364] Step 4:

[1365] The generative AI model proposes appropriate countermeasures based on the identified cause of the failure, and the proposals are written in natural language and provided to the user.

[1366] Input: Identified cause of failure

[1367] Output: Natural language suggestions for how to address the issue

[1368] Specific behavior:

[1369] The generative AI model extracts countermeasures such as "restart the port" or "replace the cable" from the history of past fault handling, and generates a suggestion text in natural language. The server notifies the user of this suggestion text.

[1370] Step 5:

[1371] The terminal uses an emotion engine to recognize the user's emotion, which analyzes the user's emotion and transmits the information to the server.

[1372] Input: User facial expressions and voice

[1373] Output: Analyzed user emotion information

[1374] Specific behavior:

[1375] The device analyzes the user's emotions from their facial expressions and voice. For example, if the user is very angry, the emotion engine sends that information to the server.

[1376] Step 6:

[1377] The server inputs the emotional information received from the emotion engine into the generative AI model and determines the priority of fault response.

[1378] Input: Analyzed user emotion information

[1379] Output: Prioritized fault response

[1380] Specific behavior:

[1381] The server inputs the information from the emotion engine into the generative AI model, which then sets the priority of fault response as the highest priority based on that information.

[1382] In this way, the system processes a series of steps from receiving log data to identifying the cause of the failure, proposing countermeasures, and determining priorities based on the user's emotions.

[1383] (Application example 2)

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

[1385] In order to respond quickly and appropriately when a network device fails, it is important to identify the cause of the failure and propose a solution. However, in conventional systems, identifying the cause of the failure and proposing a solution are often done manually, which takes time and makes it difficult to respond while taking the user's emotions into account. In particular, in situations where a user is very angry, for example, where a response that takes into account priorities according to emotions is required, conventional systems are insufficient in their response.

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

[1387] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data, a means for monitoring syslogs sent from the network devices in real time, a means for the generation AI to analyze the syslog and identify the cause of the failure, a means including an emotion engine that recognizes the user's emotions and determines the priority of the failure response based on the emotions, and a means for proposing a countermeasure based on the cause of the failure and the priority. This makes it possible to quickly identify the cause of the failure and propose an appropriate countermeasure according to the user's emotions.

[1388] The "past failure response history" is a record of responses made to past failures of network devices.

[1389] "Syslog" is a system log output by network devices, and contains information such as the device's operating status and error messages.

[1390] A "manufacturer's manual" is an instruction manual or technical document provided by the manufacturer of network equipment, which describes the specifications of the equipment and how to respond in the event of a malfunction.

[1391] "Generative AI" is a system that uses artificial intelligence technology to identify the cause of a failure from training data and suggest ways to deal with it.

[1392] "Network equipment" refers to hardware devices used to build and operate networks, including routers and switches.

[1393] "Monitoring in real time" means instantly monitoring the syslog sent from network devices and immediately detecting abnormalities or failures.

[1394] An "emotion engine" is a technology that recognizes a user's emotions and adjusts the system's behavior based on those emotions.

[1395] "Deciding priorities" means deciding which of multiple failure responses should be performed first.

[1396] "Proposing a solution" means presenting appropriate countermeasures, such as repairs or setting changes, for the identified cause of the failure.

[1397] As an embodiment of the present invention, a method for installing a security AI assistant system on a smartphone will be described.

[1398] System Programming

[1399] The security AI assistant system includes the following main components:

[1400] 1. Syslog monitoring module: Monitors syslogs sent from network devices in real time.

[1401] 2. Generative AI module: Analyzes syslog and identifies the cause of failure.

[1402] 3. Emotion engine module: Recognizes user emotions and prioritizes fault responses based on those emotions.

[1403] 4. Countermeasure suggestion module: Proposes appropriate countermeasures based on the cause of the failure and priority.

[1404] Hardware and Software

[1405] Hardware: Smartphone

[1406] software:

[1407] Python

[1408] syslog_parser library (syslog parsing)

[1409] ai_model library (generative AI models)

[1410] emotion_engine library (emotion engine)

[1411] Data processing and calculation

[1412] 1. Syslog monitoring: The server uses the syslog_parser library to monitor syslogs sent from network devices in real time, allowing for immediate detection of abnormalities and failures.

[1413] 2. Identifying the cause of the failure: The server uses the generation AI module to analyze the monitored syslog and identify the cause of the failure. The generation AI uses past failure response history and manufacturer manuals as learning data.

[1414] 3. Emotion Recognition: The device uses the emotion engine module to recognize the user's emotions. For example, if the user is very angry, it conveys that information to the generation AI.

[1415] 4. Priority determination: The server determines the priority of fault handling based on the recognized user sentiment.

[1416] 5. Proposing countermeasures: The server proposes appropriate countermeasures to the user in natural language based on the cause of the failure and priority.

[1417] Examples

[1418] For example, if a network switch breaks down and the syslog contains the error message "port error," the generative AI will determine that there is a problem with the port. Based on past troubleshooting history, it will suggest "restart the port" or "replace the cable." Furthermore, if the user is very angry, the emotion engine will communicate that information to the generative AI, making troubleshooting the top priority.

[1419] Examples of prompt statements

[1420] syslog: "port error detected on port 3"

[1421] user_emotion: "angry"

[1422] By inputting this prompt sentence into a generative AI model, the cause of the failure is identified and a solution is suggested.

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

[1424] Step 1:

[1425] The server uses the syslog_parser library to monitor syslogs sent from network devices in real time. The input is the syslog sent from the network device, and the output is the parsed syslog message. When the server receives a syslog message, it immediately analyzes it to detect any abnormalities or signs of failure.

[1426] Step 2:

[1427] The server uses a generation AI module to receive the analyzed syslog message as input and identify the cause of the failure. The generation AI uses past failure response history and manufacturer manuals as learning data. The output is the identified cause of the failure. The server analyzes error messages and warnings contained in the syslog message and identifies the cause of the failure.

[1428] Step 3:

[1429] The device recognizes the user's emotions using an emotion engine module. The input is the user's voice and facial expression data, and the output is the recognized emotional state of the user. The device captures the user's voice and facial expressions through a camera and microphone, and the emotion engine analyzes them to identify the user's emotional state.

[1430] Step 4:

[1431] The server receives the recognized emotional state of the user as input and determines the priority of the fault response. The output is the determined priority. If the user is very angry, the server conveys that information to the generation AI, which gives the top priority to the fault response.

[1432] Step 5:

[1433] The server uses a generation AI module to propose an appropriate solution based on the cause of the failure and the priority order. The input is the identified cause of the failure and the determined priority order, and the output is the proposed solution. The generation AI of the server refers to past failure response history and manufacturer manuals, and proposes the optimal solution to the user in natural language.

[1434] Step 6:

[1435] The user receives the suggested solution from the server and actually takes action. The input is the solution suggested by the server, and the output is the result of the solution that was actually taken. The user takes action such as rebooting the port or replacing the cable according to the instructions from the server.

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

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

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

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

[1440] [Fourth embodiment]

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

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

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

[1444] 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 is

[1445] The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. In addition, a microphone 238, a speaker 240, a camera 42, and a control target 443 are also connected to the bus 52.

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

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

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

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

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

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

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

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

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

[1455] "Example 1"

[1456] One embodiment of the present invention is a system including a generation AI that uses past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data. This system receives as input the syslogs output by network devices when a failure occurs, and identifies the cause of the failure based on the learning data. Furthermore, based on the identified cause of the failure, the system proposes an appropriate countermeasure in natural language.

[1457] "Example 2"

[1458] As a specific example, consider the case where a network switch breaks down. The syslog output by the switch when a failure occurs is input into the generation AI. The generation AI identifies the cause of the failure from the syslog based on the past failure response history and manufacturer manuals used as learning data. For example, if the syslog contains the error message "port error," the generation AI will determine that there is a problem with the port. Then, based on the past failure response history, it will suggest solutions in natural language, such as "restart the port" or "replace the cable."

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

[1460] "Example 1"

[1461] Step 1: Input the syslog output by the network device when a failure occurs into the generation AI.

[1462] Step 2: The generating AI identifies the cause of the failure from the syslog based on past failure response history and manufacturer manuals used as learning data.

[1463] Step 3: Based on the identified cause of the failure, an appropriate countermeasure is suggested in natural language.

[1464] "Example 2"

[1465] Step 1: When a network switch fails, the syslog output by the switch at the time of the failure is input into the generation AI.

[1466] Step 2: Generate AI checks the error message contained in the syslog (e.g. "port

[1467] error") and determines that there is a problem with the port.

[1468] Step 3: The generative AI suggests solutions in natural language, such as "restart the port" or "replace the cable," based on past fault response history.

[1469] Example 1

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

[1471] When a failure occurs in network equipment, it is necessary to quickly and accurately identify the cause and provide the user with an appropriate solution. However, with conventional systems, it takes time to identify the cause of the failure and propose a solution, which means the user cannot respond quickly. In addition, it is difficult to effectively use past failure response history and manufacturer manuals, which can reduce the efficiency of failure response.

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

[1473] In this invention, the server includes a means for receiving log data transmitted from a network device, a means for analyzing the received log data and extracting an error message, a means for inputting the extracted error message to a generative AI model, a means for the generative AI model to use past failure response history, log data, and a manufacturer manual as learning data to identify the cause of the failure, a means for the generative AI model to generate an appropriate countermeasure in natural language based on the identified cause of the failure, and a means for notifying a user of the generated countermeasure. This makes it possible to quickly and accurately identify the cause of a failure in a network device and provide the user with an appropriate countermeasure.

[1474] A "network device" is a hardware device for conducting data communications, and includes routers, switches, firewalls, etc.

[1475] "Log data" refers to recorded information generated by network devices during operation, and includes error messages and warning messages.

[1476] An "error message" is warning information that is output when a network device detects a failure or abnormality.

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

[1478] "Failure response history" refers to data that records past failures and how they were handled.

[1479] A "manufacturer's manual" is a document that includes operating procedures and troubleshooting guides provided by the manufacturer of network equipment.

[1480] "Natural language" refers to the language used by humans on a daily basis, and is the form of response output by generative AI models.

[1481] "User" means an individual or organization that manages and operates network equipment.

[1482] A "notification" is an action in which the server conveys information to the user, and is carried out via email or the dashboard.

[1483] The present invention is a system for quickly and accurately identifying the cause of a fault in a network device and providing a user with an appropriate solution. A specific embodiment of this system will be described below.

[1484] Hardware and software used

[1485] Hardware: Server (e.g. general-purpose server)

[1486] Software: Generative AI models (e.g., general generative AI models), syslog analysis tools (e.g., general log analysis tools)

[1487] System Configuration

[1488] 1. The server receives log data sent from the network device. Specifically, the server functions as a syslog server and receives log data from the network device on port 514.

[1489] 2. The server analyzes the received log data and extracts error messages. Specifically, the server uses a log analysis tool to extract error messages and warning messages from the log data.

[1490] 3. The server prepares the extracted error message as data to be input to the generative AI model. Specifically, it formats the error message in text format and launches the generative AI model.

[1491] 4. The server inputs the error message into the generative AI model to identify the cause of the failure. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data, and estimates the cause of the failure based on the error message.

[1492] 5. The server uses a generative AI model to generate an appropriate solution based on the identified cause of the failure. The generative AI model proposes the solution in natural language.

[1493] 6. The server notifies the user of the generated solution. Specifically, the server provides the solution to the user via email or dashboard.

[1494] Examples

[1495] 1. The network device outputs log data containing the error message "Interface down."

[1496] 2. The server receives this log data and extracts the error message "Interface down."

[1497] 3. The server inputs the error message "Interface down" into the generative AI model.

[1498] 4. The generative AI model refers to past fault response history and manufacturer manuals to identify "broken cable" or "port failure" as the cause of "Interface down."

[1499] 5. The generative AI model then uses natural language to suggest solutions such as "check the cable and replace if necessary" or "restart the port."

[1500] 6. The server notifies the user of this solution.

[1501] Examples of prompt statements

[1502] "The log data from a network device contains the error message 'Interface down'. What is the cause of this error message and how can I resolve it?"

[1503] In this way, the server realizes a system that identifies the cause of a failure in a network device and provides the user with an appropriate solution.

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

[1505] Step 1:

[1506] The server receives log data sent from the network device. Specifically, the server functions as a syslog server and receives log data from the network device on port 514. The input is the log data from the network device, and the output is the received log data.

[1507] Step 2:

[1508] The server analyzes the received log data and extracts error messages. Specifically, it uses a log analysis tool to filter error messages and warning messages from the log data. The input is the received log data and the output is the extracted error messages.

[1509] Step 3:

[1510] The server prepares the extracted error message as data to be input to the generative AI model. Specifically, it formats the error message in text format and launches the generative AI model. The input is the extracted error message, and the output is the text data to be input to the generative AI model.

[1511] Step 4:

[1512] The server inputs error messages into the generative AI model and identifies the cause of the failure. The generative AI model uses past failure response history, log data, and manufacturer manuals as learning data, and estimates the cause of the failure based on the error message. The input is the text data input into the generative AI model, and the output is the identified cause of the failure.

[1513] Step 5:

[1514] The server uses a generative AI model to generate an appropriate solution based on the identified cause of the failure. The generative AI model proposes a solution in natural language. The input is the identified cause of the failure, and the output is the generated solution.

[1515] Step 6:

[1516] The server notifies the user of the generated solution. Specifically, the solution is provided to the user via email or a dashboard. The input is the generated solution, and the output is the solution notified to the user.

[1517] (Application example 1)

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

[1519] Robots operating in factories need to be diagnosed and repaired quickly and accurately when they break down. However, with conventional systems, it was difficult to identify the cause of the failure or propose an appropriate solution, and repairs often took a long time. There was also the problem that a technician with specialized knowledge was always needed, which increased costs. To solve these issues, a system was needed that could quickly identify the cause of the failure and automatically propose an appropriate solution.

[1520] The identification process by the identification processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means. In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslog output by a network device when a failure occurs, and manufacturer manuals as learning data, a means for diagnosing a failure and providing repair support for a robot operating in a factory, a means for analyzing the syslog output by a robot when a failure occurs and identifying the cause of the failure, and a means for proposing an appropriate countermeasure in natural language based on the identified cause of the failure. This makes it possible to quickly identify the cause of the failure and automatically propose an appropriate countermeasure.

[1521] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[1522] The "syslog output by a network device when a failure occurs" is log data that is generated when a network device fails, and includes detailed information about the failure.

[1523] "Manufacturer's Manual" means an instruction manual or technical documentation provided by a product manufacturer that includes information on how to use the product and troubleshooting.

[1524] "Generative AI" is artificial intelligence that generates new information based on learning data, identifying the cause of failures and proposing countermeasures.

[1525] A "factory robot" is an automated machine designed to perform tasks in a factory.

[1526] "Fault diagnosis" is the analytical process for determining the cause of a fault.

[1527] "Repair assistance" refers to the provision of information and assistance to assist in the repair of broken equipment.

[1528] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[1529] "Analysis" is the process of examining data in detail to understand its meaning and structure.

[1530] "Solutions" are specific actions or steps to be taken in response to an identified problem.

[1531] In order to implement the present invention, the following system configuration and program are required.

[1532] The server contains a generative AI model that uses past fault response history, syslogs output by network devices when a fault occurs, and manufacturer manuals as learning data. This generative AI model analyzes the syslogs output by the robot when a fault occurs and identifies the cause of the fault. It also proposes appropriate countermeasures in natural language based on the identified cause of the fault.

[1533] Specifically, the server performs the following process.

[1534] 1. Data collection and analysis:

[1535] The server receives syslog data sent from robots operating in the factory. The received syslog data is parsed using the syslog_parser module. This analysis extracts detailed information about the failure.

[1536] 2. Identifying the cause of the failure:

[1537] The analyzed data is input to the generative AI model, which has learned from past fault response history and manufacturer manuals, and identifies the cause of the fault based on this. The ai_model module is used for this identification.

[1538] 3. Suggested solutions:

[1539] Based on the identified fault causes, the generative AI model generates appropriate countermeasures, which are generated using the ai_model module. The generated countermeasures are then converted into natural language using the natural_language_processor module.

[1540] 4. Notice to Users:

[1541] The solution converted into natural language is notified to the user, so that the user can quickly take the appropriate solution.

[1542] As a concrete example, by inputting the following prompt sentence into the generative AI model, the cause of the failure and how to deal with it can be identified.

[1543] Prompt text: "2023-10-01 12:00:00 ERROR: Motor failure in section A"

[1544] Using this prompt as input, the generative AI model produces the following output:

[1545] Output: "A motor failure has occurred in section A. Please attempt to restart the motor based on past failure history and manufacturer manual. If restarting is unsuccessful, the motor will need to be replaced."

[1546] In this way, the server can quickly identify the cause of a failure and automatically suggest appropriate countermeasures, which will efficiently diagnose failures and provide repair support for robots operating in factories.

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

[1548] Step 1:

[1549] The server receives syslog data sent from robots operating in the factory. The input is the syslog data from the robot, and the output is the received syslog data. This data includes detailed information such as the time when the failure occurred and error messages.

[1550] Step 2:

[1551] The server parses the received syslog data using the syslog_parser module. The input is the received syslog data, and the output is the parsed failure information. This parsing extracts detailed information such as error messages and the location of the failure.

[1552] Step 3:

[1553] The server inputs the analyzed failure information into the generative AI model. The input is the analyzed failure information, and the output is the identified cause of the failure. The generative AI model learns from past failure response history and manufacturer manuals, and identifies the cause of the failure based on this.

[1554] Step 4:

[1555] The server uses a generative AI model to generate appropriate countermeasures based on the identified cause of the failure. The input is the identified cause of the failure, and the output is the generated countermeasure. The countermeasure is generated based on the history of past failure responses and the manufacturer's manual.

[1556] Step 5:

[1557] The server converts the generated action into natural language using the natural_language_processor module. The input is the generated action and the output is the action converted into natural language. This conversion provides the action in a form that is easy for the user to understand.

[1558] Step 6:

[1559] The server notifies the user of the solution converted into natural language. The input is the solution converted into natural language, and the output is a notification to the user. This allows the user to quickly take appropriate measures.

[1560] Example 2

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

[1562] When network equipment fails, there is a need to quickly and accurately identify the cause of the failure and propose appropriate countermeasures. However, with conventional systems, it takes time to identify the cause of the failure and propose countermeasures, and engineers with specialized knowledge are required, making it difficult to respond to failures efficiently.

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

[1564] In this invention, the server includes a means for receiving log data transmitted from a network device, a means for analyzing the log data and extracting an error message, a means for inputting the extracted error message into a generative AI model and identifying the cause of a failure, a means for proposing a countermeasure based on the cause of the failure by the generative AI model, and a means for notifying a user of the proposed countermeasure. This makes it possible to quickly and accurately identify the cause of a failure and propose an appropriate countermeasure.

[1565] A "network device" is a hardware device for data communication, including routers and switches.

[1566] "Log data" refers to recorded information generated by a network device during operation, and includes error messages and event information.

[1567] An "error message" is a message that is output by a network device when it detects an abnormality, and contains information that is useful for identifying the cause of the failure.

[1568] A "generative AI model" is a model that is trained using artificial intelligence technology to perform specific tasks, such as identifying the cause of a failure and proposing countermeasures based on past data and technical documentation.

[1569] The "cause of failure" is a factor that prevents a network device from operating normally, and is identified from error messages and log data.

[1570] A "remedy" is a remedial measure taken to address the identified cause of the failure, such as rebooting the port or replacing the cable.

[1571] "User" means a person or organization that manages and operates network equipment and is the recipient of troubleshooting proposals.

[1572] The present invention is a system for quickly and accurately identifying the cause of a failure when a network device fails and proposing an appropriate countermeasure. A specific embodiment of this system will be described below.

[1573] The server receives log data sent from the network devices. The log data includes the operating status of the network devices and error messages. The server analyzes the received log data and extracts error messages. This analysis includes checking the format of the data and extracting error messages.

[1574] Next, the server inputs the extracted error message into the generative AI model. The generative AI model uses past fault response history and technical documents as learning data and identifies the cause of the fault from the error message. For example, if the error message contains "port error," the generative AI model will determine that there is a problem with the port.

[1575] After the cause of the failure is identified, the server uses a generative AI model to suggest appropriate countermeasures. The suggestions are generated based on past failure response history and technical documentation. For example, countermeasures such as "restart the port" or "replace the cable" are suggested.

[1576] Finally, the server notifies the user of the proposed solution. Possible notification methods include email and display on the dashboard. This allows the user to quickly identify the cause of the failure and implement the appropriate solution.

[1577] To illustrate, consider the following scenario:

[1578] The server receives log data "2023-10-01 12:00:00 port error detected on port 3" from the network device.

[1579] The server analyzes this log data and extracts the error message "port error."

[1580] The server inputs the extracted error messages into a generative AI model to identify the cause of the failure.

[1581] The generative AI model determines that there is a problem with the port and suggests restarting the port or replacing the cable.

[1582] The server will notify the user of the proposal via email.

[1583] Example prompt:

[1584] Syslog data: "2023-10-01 12:00:00 port error detected on port 3"

[1585] Prompt for generative AI model: "Please identify the cause of the failure from this syslog data and suggest appropriate countermeasures."

[1586] In this way, the server can receive log data, analyze it, and use a generative AI model to identify the cause of the failure and notify the user of the appropriate course of action.

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

[1588] Step 1:

[1589] The server receives the log data transmitted from the network device.

[1590] Specifically, the server listens to a network port and receives log data in real time, which is then temporarily stored.

[1591] Input: Log data from network devices

[1592] Output: Temporarily saved log data

[1593] Step 2:

[1594] The server analyzes the received log data and extracts error messages.

[1595] Specifically, the server checks the format of the log data and extracts the part containing the error message. Regular expressions and pattern matching techniques are used for analysis.

[1596] Input: Temporarily saved log data

[1597] Output: Extracted error message

[1598] Step 3:

[1599] The server inputs the extracted error messages into a generative AI model to identify the cause of the failure.

[1600] Specifically, the server inputs the error message as a prompt to the generative AI model, which then identifies the cause of the failure based on past failure response history and technical documentation.

[1601] Input: The extracted error message

[1602] Output: Identified cause of failure

[1603] Step 4:

[1604] The server then suggests countermeasures based on the causes of the failure identified using the generative AI model.

[1605] Specifically, the server generates appropriate countermeasures based on the cause of the failure obtained from the generative AI model. Countermeasures are proposed based on past failure response history and technical documentation.

[1606] Input: Identified cause of failure

[1607] Output: Suggested action to be taken

[1608] Step 5:

[1609] The server will notify the user of the suggested course of action.

[1610] Specifically, the server retrieves the user's contact information and sends the suggestions via email or dashboard.

[1611] Input: Proposed action

[1612] Output:Notification to the user

[1613] In this way, the server can receive log data, analyze it, and use a generative AI model to identify the cause of the failure and notify the user of the appropriate course of action.

[1614] (Application example 2)

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

[1616] When a factory robot breaks down, it is necessary to quickly and accurately identify the cause of the failure and propose an appropriate solution. However, with conventional systems, it takes time to identify the cause of the failure and propose a solution, which prolongs factory downtime. In addition, there is also the issue of the constant need for engineers with specialized knowledge, which is costly.

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

[1618] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, log data output by the network device when a failure occurs, and the manufacturer's manual as learning data, a means for analyzing in real time the log data generated when the factory robot breaks down, a means for proposing a specific countermeasure based on the past failure response history and the manufacturer's manual, and a means for outputting the generated cause of the failure and the countermeasure in natural language. This enables a quick and accurate response when the factory robot breaks down.

[1619] "Past failure response history" refers to a record of responses made to failures that have occurred in the past.

[1620] The "log data output by a network device when a failure occurs" is data that includes error messages and status information that are generated when a network device fails.

[1621] A "manufacturer's manual" is a document provided by a manufacturer regarding how to use and troubleshoot a device.

[1622] "Generative AI" is artificial intelligence that learns from past data and identifies the cause of failures and generates countermeasures based on new data.

[1623] A "factory robot" is a mechanical device used to perform automated tasks in a factory.

[1624] "Real-time analysis" means analyzing data as soon as it is generated.

[1625] "Providing suggestions in natural language" means presenting solutions in terms that are easy for humans to understand.

[1626] A "cause of failure" is a factor that causes equipment to not operate normally.

[1627] A "measure" is a method for correcting a malfunction and returning the equipment to a normal state.

[1628] The system for carrying out the present invention is for quickly and accurately dealing with the breakdown of a factory robot. A specific embodiment of the system is described below.

[1629] System Configuration

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

[1631] 1. Server: A computer system for running the generative AI model.

[1632] 2. Factory Robot: A mechanical device that performs automated tasks in a factory.

[1633] 3. Network equipment: Equipment for communication between the robot and the server.

[1634] Hardware and Software Used

[1635] Hardware: Factory robots, servers, network equipment

[1636] Software: Python, OpenAI API

[1637] Data processing and calculation

[1638] Server Processing

[1639] 1. Log data collection: The server collects log data generated when a factory robot breaks down.

[1640] 2. Prompt sentence generation: The server generates prompt sentences to be input into the generative AI model based on the collected log data.

[1641] 3. Analysis by generative AI: The server uses the OpenAI API to input prompt text into the generative AI model to generate the cause of the failure and a solution.

[1642] 4. Output of results: The server outputs the generated cause of the fault and how to deal with it in natural language and presents it to the user.

[1643] Examples

[1644] For example, if a factory robot generates log data containing the error message "port error on port 3," the server inputs the following prompt sentence into the generative AI model:

[1645] Examples of prompt statements

[1646] Please analyze the following log data and suggest the cause of the failure and how to deal with it.

[1647] Log data: 2023-10-01 12:00:00 ERROR: port error on port 3

[1648] Based on this prompt, the generative AI model determines that "there is a problem with port 3" and suggests solutions such as "restarting the port" or "replacing the cable."

[1649] effect

[1650] This system enables a rapid and accurate response when a factory robot breaks down, minimizing factory downtime. It also contributes to cost reduction because engineers with specialized knowledge are not always required.

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

[1652] Step 1:

[1653] The server collects log data that is generated when a factory robot breaks down. The log data includes error messages and status information. This log data is input. The server receives the log data via the network and stores it in a database.

[1654] Step 2:

[1655] The server generates a prompt sentence to be input to the generative AI model based on the collected log data. The input data for generating this prompt sentence is the log data collected in step 1. The server analyzes the log data and creates a prompt sentence in an appropriate format. For example, the format is "Analyze the following log data and propose the cause of the failure and how to deal with it. Log data: 2023-10-01 12:00:00 ERROR: port error on port 3."

[1656] Step 3:

[1657] The server inputs the generated prompt sentence into the generative AI model using the OpenAI API. This prompt sentence becomes the input. The generative AI model uses past fault response history and manufacturer manuals as learning data, and generates the cause of the fault and a solution based on the prompt sentence. The generated cause of the fault and a solution become the output.

[1658] Step 4:

[1659] The server outputs the cause of the failure and the countermeasure obtained from the generative AI model in natural language and presents it to the user. This output is displayed in a format that is easy for the user to understand. For example, it could be in the format of "There is a problem with port 3, so please restart the port." The server displays this information through a user interface.

[1660] Step 5:

[1661] The user repairs the factory robot based on the solution presented by the server. The user performs specific repair work according to the instructions from the server, such as restarting a port or replacing a cable. After the user completes the repair, he or she reports the completion of the repair to the server.

[1662] In this way, a rapid and accurate response can be made when a factory robot breaks down.

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

[1664] "Example 1"

[1665] As one embodiment of the present invention, a system including an emotion engine that recognizes the emotions of a user is provided. This system includes a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using past failure response history, syslogs output by network devices when a failure occurs, and manufacturer manuals as learning data. Furthermore, this generation AI includes an emotion engine that recognizes the emotions of a user. This emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and language, and adjusts the identification of the cause of the failure and the proposal of a countermeasure based on the emotion. For example, if the user is angry, the emotion engine conveys that information to the generation AI, and the generation AI proposes a more rapid countermeasure.

[1666] "Example 2"

[1667] As another embodiment, a system is provided in which an emotion engine determines the priority of fault handling based on the emotion of a user. This system is a further development of the system described in claim 4. Specifically, the emotion engine recognizes the emotion of a user and determines the priority of fault handling based on the emotion. For example, if a user is very angry, the emotion engine conveys that information to the generation AI, and the generation AI gives top priority to that fault handling. This enables more appropriate fault handling according to the emotion of the user.

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

[1669] "Example 1"

[1670] Step 1: Recognize the user's emotions The emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and choice of words.

[1671] Step 2: The emotion engine communicates the recognized user emotion to the generative AI.

[1672] Step 3: The generation AI adjusts the identification of the cause of the failure and the proposed solution based on the user's emotions. For example, if the user is angry, the generation AI will suggest a quicker solution. "Example 2"

[1673] Step 1: Recognize the user's emotions The emotion engine recognizes the user's emotions from the user's tone of voice, facial expressions, and choice of words.

[1674] Step 2: The emotion engine communicates the recognized user emotion to the generative AI.

[1675] Step 3: The generative AI prioritizes the fault response based on the user's emotions. For example, if the user is very angry, the generative AI gives top priority to that fault response.

[1676] Example 1

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

[1678] Conventional troubleshooting systems often fail to quickly and accurately identify the cause of a malfunction or propose a solution, and they have a particular problem in that it is difficult to respond to the user's emotions. This leads to a decrease in user satisfaction and a deterioration in the efficiency of troubleshooting.

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

[1680] In this invention, the server includes a means including a generation AI that identifies the cause of a failure and proposes a countermeasure in natural language using the past failure response history, the log data output by the information processing device when a failure occurs, and technical documents as learning data, a means for receiving the log data output by the information processing device when a failure occurs, a means including an emotion engine that recognizes the user's emotion, and a means for adjusting the proposed countermeasure based on the user's emotion information. This makes it possible to quickly and accurately identify the cause of the failure and propose an appropriate countermeasure according to the user's emotion.

[1681] The "past failure response history" is data that records the response methods and results of failures that have occurred in the past.

[1682] "Log data" refers to data that records events and error messages that are generated by an information processing device during its operation.

[1683] "Technical documentation" refers to documents that contain product specifications, operating instructions, troubleshooting guides, etc.

[1684] "Generative AI" is an artificial intelligence that uses learning data to identify the cause of a failure and suggest ways to deal with it.

[1685] The "emotion engine" is a system that recognizes emotions from the user's tone of voice, facial expressions, choice of words, etc.

[1686] "Information processing device" is a general term for devices that input, process, and output data.

[1687] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[1688] The present invention is a system that analyzes log data output when a failure occurs in a network device, identifies the cause of the failure based on past failure response history and technical documents, and proposes appropriate countermeasures.Furthermore, it has a function to recognize the user's emotions and propose countermeasures according to those emotions.

[1689] System Configuration

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

[1691] 1. Server

[1692] The server receives and analyzes the log data sent from the network devices. Specifically, the server monitors the log data in real time and saves the received data in a log file.

[1693] The server is equipped with a generation AI that uses past fault response history and technical documents as learning data. The generation AI analyzes the log data and identifies the cause of the fault.

[1694] 2. Terminal

[1695] The device is responsible for inputting the user's tone of voice, facial expressions, and vocabulary into the emotion engine. Specifically, the device uses a microphone and camera to capture the user's voice and video and transmits them to the emotion engine.

[1696] The terminal displays the solution sent from the server to the user.

[1697] 3. Emotion Engine

[1698] The emotion engine recognizes emotions from the user's tone of voice, facial expressions, vocabulary, etc. The emotion engine performs voice and image analysis to identify the user's emotional state (e.g. anger, sadness, joy).

[1699] The emotion engine conveys the recognized emotional information to the generative AI.

[1700] System Operation

[1701] 1. Data Entry

[1702] The server receives log data sent from the network device. For example, when the network device outputs log data of "link down", the server receives this information and stores it in a log file.

[1703] The device captures the user's tone of voice and facial expressions and sends them to the emotion engine.

[1704] 2. Data Processing

[1705] The server analyzes the received log data. Specifically, the server parses the contents of the log data and extracts error messages and warning messages.

[1706] The generation AI identifies the cause of the failure based on the analysis results and learning data. For example, the generation AI refers to the response history of past link downs and technical documentation and identifies the cause of the failure as a "broken cable."

[1707] The emotion engine recognizes "anger" from the tone of the user's voice and conveys that information to the generation AI.

[1708] 3. Proposal for solutions

[1709] The generation AI generates appropriate countermeasures in natural language based on the identified cause of the failure and the user's emotional information. For example, the generation AI refers to standard countermeasures for the cause of the failure and adjusts the proposed content according to the user's emotional state.

[1710] The server transmits the generated solution to the terminal, and the terminal displays the content of the solution to the user.

[1711] Examples

[1712] For example, when a network device outputs log data indicating "link down," the process proceeds as follows.

[1713] 1. The server receives the "link down" log data and saves it in a log file.

[1714] 2. The device captures the user's tone of voice and facial expressions and sends them to the emotion engine.

[1715] 3. The server parses the contents of the log data and extracts the "link down" error message.

[1716] 4. The generation AI refers to the response history of past link-downs and technical documentation, and identifies the cause of the failure as a "broken cable."

[1717] 5. The emotion engine recognizes "anger" from the tone of the user's voice and conveys that information to the generation AI.

[1718] 6. Based on the cause of the failure and the user's emotional information of "anger," the generative AI will suggest "replacing the cable immediately."

[1719] 7. The server sends the generated solution to the terminal, and the terminal displays it to the user.

[1720] Examples of prompt statements

[1721] "The network device has output log data indicating a link down. Please identify the cause of the failure based on past support history and technical documentation, and propose a quick response method in case the user is angry."

[1722] In this way, the system makes it possible to efficiently respond to network device failures and provides appropriate countermeasures according to the user's emotions.

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

[1724] Step 1:

[1725] The server receives log data sent from the network devices. Specifically, the server monitors the log data in real time and saves the received data in a log file. The input is the log data from the network devices, and the output is the saved log file.

[1726] Step 2:

[1727] The terminal inputs the user's tone of voice, facial expressions, and language into the emotion engine. Specifically, the terminal uses a microphone and camera mounted on the terminal to capture the user's voice and video and transmits them to the emotion engine. The input is the user's voice and video, and the output is the data transmitted to the emotion engine.

[1728] Step 3:

[1729] The server analyzes the received log data. Specifically, the server parses the contents of the log data and extracts error and warning messages. The input is the saved log file, and the output is the extracted error and warning messages.

[1730] Step 4:

[1731] The generation AI identifies the cause of the failure based on the analysis results and learning data. Specifically, the generation AI refers to past failure response history and technical documents to search for similar failure patterns. The inputs are the extracted error and warning messages and learning data, and the output is the identified cause of the failure.

[1732] Step 5:

[1733] The emotion engine recognizes the user's emotions and conveys that information to the generative AI. Specifically, the emotion engine performs voice and image analysis to identify the user's emotional state (e.g., anger, sadness, joy). The input is the user's voice and video, and the output is the recognized emotional information.

[1734] Step 6:

[1735] The generation AI generates appropriate countermeasures in natural language based on the identified cause of the failure and the user's emotional information. Specifically, the generation AI refers to standard countermeasures for the cause of the failure and adjusts the proposed content according to the user's emotional state. The input is the identified cause of the failure and the recognized emotional information, and the output is the generated countermeasure.

[1736] Step 7:

[1737] The server transmits the generated solution to the terminal, and the terminal displays the content to the user. Specifically, the server transmits the generated solution to the terminal, and the terminal displays the content on the screen. The input is the generated solution, and the output is the solution displayed to the user.

[1738] (Application example 1)

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

[1740] Conventional fault response systems often fail to quickly and accurately identify the cause of a fault or propose countermeasures, making it particularly difficult to respond flexibly to the user's emotions. In addition, when responding to faults in robots operating in factories, it is necessary to respond in a way that takes into account the emotions of the operator, but there was a lack of technology to achieve this.

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

[1742] In this invention, the server includes a means including a generation AI that uses past failure response history, log data output by the information processing device when a failure occurs, and technical documents as learning data to identify the cause of the failure and propose a countermeasure in natural language, a means for the generation AI to identify the cause of the failure from the log data output by the information processing device when a failure occurs, a means to propose a countermeasure based on the cause of the failure, a means including an emotion recognition engine that recognizes the user's emotions, and a means for the emotion recognition engine to recognize the user's emotions from the user's tone of voice, facial expression, and wording, and to adjust the identification of the cause of the failure and the proposal of the countermeasure based on the emotions. This makes it possible to quickly and accurately identify the cause of the failure and propose a flexible countermeasure according to the user's emotions.

[1743] The "past failure response history" is a record of responses made to failures that have occurred in the past.

[1744] "Log data" is a record of events and errors generated by an information processing device during operation.

[1745] "Technical documentation" refers to documents that describe product or system specifications, operation methods, troubleshooting, etc.

[1746] "Generative AI" is artificial intelligence that generates new information based on training data and performs specific tasks.

[1747] An "emotion recognition engine" is a system that analyzes and recognizes emotions from a user's tone of voice, facial expressions, choice of words, etc.

[1748] "Identifying the cause of a failure" means clarifying the fundamental cause of a failure that has occurred.

[1749] "Proposing a solution" means presenting appropriate repair or response procedures based on the identified cause of the failure.

[1750] "Natural language" is language used by humans on a daily basis, often translated into a form that is easy for machines to understand.

[1751] "A user's tone of voice" refers to changes in pitch and intensity of the voice that indicate the speaker's emotions and intent.

[1752] "Facial expressions" are emotions and reactions shown by the movement of facial muscles.

[1753] "Language" refers to the words and expressions a speaker chooses to use, and reflects the speaker's feelings and attitudes.

[1754] A system for implementing the present invention includes an application called "Smart Maintenance Assistant" that is installed on a robot that operates in a factory. A specific embodiment of this system will be described below.

[1755] Hardware and Software Used

[1756] Hardware: Factory robots, microphones, cameras

[1757] Software: syslog parsing library (syslog_parser), emotion recognition library (emotion_recognition), generative AI model (ai_model)

[1758] System Configuration

[1759] 1. Identifying the cause of the failure:

[1760] The server analyzes in real time the log data that is output when the robot breaks down. Using a syslog analysis library, the server identifies the cause of the failure from the log data. Specifically, the server analyzes the log data based on past failure response history and technical documentation to clarify the root cause of the failure.

[1761] 2. Suggested solutions:

[1762] The server uses a generative AI model to propose appropriate countermeasures based on the identified cause of the failure. This generative AI model uses past failure response history and technical documents as learning data and proposes countermeasures in natural language.

[1763] 3. Emotion recognition:

[1764] The server uses emotion recognition libraries to analyze the user's tone of voice, facial expressions, and phrasing. Using microphones and cameras, it recognizes the user's emotions in real time. For example, if the user is angry, the emotion recogniti...

Claims

1. A means for recognizing a user's emotion using an emotion engine; A means for identifying a cause of a failure and generating a method of dealing with the failure using a generation AI model based on a prompt sentence that combines log data output by an information processing device when a failure occurs, a history of past failure responses, and technical documents; having The system, wherein the generating means generates the countermeasure based on the recognized emotion of the user.

2. The system of claim 1 , wherein the emotion engine recognizes emotions from the user's tone of voice, facial expressions, and language.

3. The system of claim 1 , wherein the generating means prioritizes the countermeasures based on the recognized emotions of the user.

Images