System

Abstract

A system is provided.SOLUTION: A system comprising: means for receiving contents of a system fault or an error from a user; means for analyzing an error log based on the received error contents; means for analyzing a cause of the error using a generative AI model; means for generating an error solution based on a result of the analysis; and means for presenting the generated error solution to the user.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] In recent years, systems have become increasingly complex, making the process of detecting system failures and errors, analyzing their causes, and formulating countermeasures more complex. As a result, system engineers are forced to spend a great deal of time and resources. There is a need to solve this problem, significantly reduce the workload of system engineers, and improve the speed of error recovery. [Means for solving the problem]

[0005] The present invention solves the problem by providing a system that includes the following means: a means for receiving details of a system failure or error from a user, a means for analyzing an error log based on the received error details, a means for analyzing the cause of the error using a generative AI model, a means for generating a solution to the error based on the analysis results, and a means for presenting the generated solution to the error to the user. The system also includes a means for receiving system code and using a generative AI model to provide feedback on analyzing and optimizing the code, and a means for using the generative AI model to provide personalized advice based on the user's past question history and feedback. In this way, the system automates the process from detecting system errors to analyzing their causes and planning countermeasures, thereby improving error recovery speed and reducing the workload of system personnel.

[0006] "User" means a person or entity that uses the system to report errors or ask questions.

[0007] A "terminal" is a device that a user uses to access the system, report errors, enter questions, and view solutions.

[0008] The "server" is a central processing unit that receives error reports and questions from users, analyzes and processes them using a generative AI model, and sends the results to the terminal.

[0009] A "generative AI model" is a collection of algorithms and programs that use artificial intelligence techniques to automatically perform error analysis, solution generation, code review, and personalized advice.

[0010] A "system failure" is a phenomenon or problem that causes a system to stop functioning properly, and is reported by users.

[0011] An "error log" is detailed information and records about errors that occur within a system, and is used as a reference when analyzing errors.

[0012] The "cause of the error" is the underlying reason or factor that caused the system failure, and is the subject of analysis by the generative AI model.

[0013] An "error solution" is a specific response method or correction procedure that is generated based on the cause of the error and is presented to the user.

[0014] "Code" refers to the source code that makes up a program, and is the subject of analysis and optimization.

[0015] "Code review" is the process of evaluating source code and providing suggestions for improvements and optimizations, and is done automatically using generative AI models.

[0016] "Personalized advice" refers to individual advice and instructions provided based on each user's past question history and feedback. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0025] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0038] This invention is a system that automates the process from detecting system errors to analyzing their causes and planning countermeasures. The system utilizes a generative AI model to analyze errors based on user reports and propose appropriate solutions. It also provides code reviews and personalized advice.

[0039] Interactive Debugging Implementation

[0040] 1. Receiving Error Reports

[0041] A user inputs a system failure or error into a terminal. For example, if a user reports that a database connection error has occurred, the terminal sends the information to the server.

[0042] 2. Error Analysis

[0043] The server analyzes system logs and error logs based on the error reports received from users. A generative AI model analyzes the log data and identifies the cause of the error, such as "The connection string may be incorrect."

[0044] 3. Providing a solution

[0045] Based on the cause of the error analyzed by the server, the generative AI model generates an appropriate solution. For example, it generates a message such as "Please check the configuration file and correct the connection string" and presents it to the user via the terminal. The user then follows the suggested solution to check and correct the system settings.

[0046] Code review support implementation example

[0047] 1. Enter and submit the code

[0048] The user enters a code to request a review into the terminal, for example, print("Hello World"), and the terminal sends the code to the server.

[0049] 2. Code Analysis

[0050] The server analyzes the received code using a generative AI model. The model detects code quality and optimization points and generates feedback, such as "Consider changing this code to print(f'Hello World')."

[0051] 3. Providing feedback

[0052] The server generates feedback and sends it to the device, which displays it to the user, who can then modify their code based on the feedback.

[0053] Embodiments of personalized advice

[0054] 1. Request for advice

[0055] A user requests advice on a specific problem, for example, "Please tell me how to fix the last error," by typing the request into the terminal and sending it to the server.

[0056] 2. Check and analyze history

[0057] The server then references the user's past question history and feedback, and generates appropriate advice based on the generative AI model. Based on information extracted from past data, the server provides specific advice such as "Check your configuration file and try a new connection string, just like last time."

[0058] 3. Providing advice

[0059] The server sends the generated advice to the terminal, which displays it to the user, who then configures and operates the system based on the advice.

[0060] Learning and teaching practices

[0061] 1. Enter and submit your question

[0062] The user types a question about a new programming language or framework into the terminal, for example, "What is a generator in Python?", which the terminal then sends to the server.

[0063] 2. Question Analysis and Answer Generation

[0064] The server inputs the received question into a generative AI model for analysis. The model understands the intent of the question and generates an appropriate answer. For example, it generates an answer such as "A generator is a method for easily creating an iterator, and uses the yield keyword."

[0065] 3. Presenting the Answer

[0066] The server generates answers and sends them to the device, which displays them to the user, who can use the information to deepen their understanding of programming languages ​​and frameworks.

[0067] Implementation of security measures

[0068] 1. Entering and Encrypting Registration Information

[0069] A user enters registration information to create a new account into the device, such as a name, email address, and password, which the device then encrypts and sends to the server.

[0070] 2. Secure Data Storage

[0071] The server will then properly decrypt the registration information received and store it securely in a database, decrypting the encrypted data and applying access controls to prevent unauthorized access.

[0072] 3. Confirmation message displayed

[0073] The server sends a confirmation message to the terminal indicating the completion of the account creation, which the terminal displays to the user. The user receives the confirmation message and confirms that the account creation was successfully completed.

[0074] In this way, the system of the present invention automates the process from error detection to cause analysis and countermeasure planning, reducing the workload of system personnel and improving the speed of error recovery.

[0075] The processing flow will be explained below.

[0076] Specific program processing for interactive debugging

[0077] Step 1:

[0078] The user enters the details of the system failure or error into the input screen of the terminal.

[0079] For example: "A database connection error has occurred."

[0080] Step 2:

[0081] The terminal transmits the error content input by the user to the server.

[0082] Step 3:

[0083] Based on the error content received by the server, the system log and error log are referenced.

[0084] Step 4:

[0085] The server reads the log file and parses it for entries related to the error.

[0086] Step 5:

[0087] The server uses the generated AI model to match the log data with the error content and identify the cause of the error.

[0088] For example: "Your connection string may be incorrect."

[0089] Step 6:

[0090] The server generates a solution to the error based on the analysis results.

[0091] For example: "Please check your configuration file and correct your connection string."

[0092] Step 7:

[0093] The server sends the generated solution message to the terminal.

[0094] Step 8:

[0095] The terminal displays the solution message received from the server to the user.

[0096] Step 9:

[0097] The user tries the suggested solutions and checks and corrects system settings.

[0098] Specific program processing for code review support

[0099] Step 1:

[0100] The user pastes the code to request a review into the input screen of the device.

[0101] Example: print("Hello World")

[0102] Step 2:

[0103] The terminal sends the code entered by the user to the server.

[0104] Step 3:

[0105] The server inputs the received code into the generative AI model.

[0106] Step 4:

[0107] The server runs a syntactic analysis of the code through a generative AI model.

[0108] Step 5:

[0109] The server uses generative AI models to generate feedback on code quality and performance.

[0110] For example: "Consider this code to be print(f"Hello World")"

[0111] Step 6:

[0112] The server generates feedback and sends it to the device.

[0113] Step 7:

[0114] The terminal displays the feedback received from the server to the user.

[0115] Step 8:

[0116] The user modifies the code based on the feedback.

[0117] Specific programmatic processing of personalized advice

[0118] Step 1:

[0119] A user requests personalized advice on a particular issue at the device.

[0120] For example: "Please tell me how to resolve the previous error."

[0121] Step 2:

[0122] The terminal sends an advice request to the server.

[0123] Step 3:

[0124] The server references the user's past question history and feedback database to obtain relevant information.

[0125] Example: Previous question "Database connection error"

[0126] Step 4:

[0127] The server uses a generative AI model to generate solutions based on historical data.

[0128] Step 5:

[0129] The server generates specific and appropriate advice.

[0130] For example: "As before, please check your configuration file and try a new connection string."

[0131] Step 6:

[0132] The server sends the generated advice to the terminal.

[0133] Step 7:

[0134] The terminal displays the advice received from the server to the user.

[0135] Step 8:

[0136] The user configures and operates the system based on the advice provided.

[0137] Specific program processing for learning and teaching

[0138] Step 1:

[0139] The user types a question about a new programming language or framework into the terminal.

[0140] For example: "What is a generator in Python?"

[0141] Step 2:

[0142] The device sends the question to the server.

[0143] Step 3:

[0144] The server inputs the received questions into a generative AI model for analysis.

[0145] Step 4:

[0146] The server uses a generative AI model to generate an appropriate answer.

[0147] For example: "Generators are methods that make iterators easier to create, and they use the yield keyword."

[0148] Step 5:

[0149] The server generates a response and sends it to the terminal.

[0150] Step 6:

[0151] The terminal displays the answer received from the server to the user.

[0152] Step 7:

[0153] Users can deepen their understanding of programming languages ​​and frameworks based on the information provided.

[0154] Specific program processing for security measures

[0155] Step 1:

[0156] The user enters registration information into the terminal to create a new account.

[0157] For example: Name, email address, password

[0158] Step 2:

[0159] The terminal encrypts the entered registration information and transmits it to the server.

[0160] Step 3:

[0161] The server properly decrypts the encrypted data to store the received registration information in a database.

[0162] Step 4:

[0163] The server enforces access control and security policies on user data.

[0164] Step 5:

[0165] The server sends a confirmation message to the device indicating that the account creation is complete.

[0166] Step 6:

[0167] The terminal displays to the user the confirmation message received from the server.

[0168] Step 7:

[0169] The user receives the provided confirmation message, confirming successful account creation.

[0170] Example 1

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

[0172] There is a need to automate the process from error detection to cause analysis and response planning, reducing the workload of system personnel while improving error recovery speed. There is also a need to provide code reviews to improve system quality and personalized advice based on users' past question history. Furthermore, from a security standpoint, secure management of user registration information is also essential.

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

[0174] In this invention, the server includes means for receiving failure or error information from a user, means for analyzing logs based on the received error information, means for identifying the cause of the error using a generative AI model, means for generating a solution to the error based on the identified cause, means for presenting the generated solution to the error to the user, means for receiving code from the user and analyzing the code using a generative AI model to generate feedback, means for presenting the generated feedback to the user, means for receiving user questions or requests and generating personalized advice based on past data using a generative AI model, means for presenting the generated advice to the user, means for receiving user registration information, appropriately encrypting it, and transmitting it to the server, and means for appropriately decoding the received information and securely storing it. This enables efficient error detection and rapid recovery, improved code quality, provision of advice tailored to the user, and secure management of registration information.

[0175] A "user" is someone who uses the system to report errors, request code reviews, or request advice.

[0176] "Terminal" means an electronic device used by a user to enter fault or error information, codes, advice requests, registration information, etc.

[0177] A "server" is a computer system that receives information sent from a terminal and uses a generative AI model to analyze and generate solutions.

[0178] "Failure or error information" refers to detailed information or messages regarding system failures or errors.

[0179] A "log" is a collection of data that records the system's operating status, error messages, etc.

[0180] A "generative AI model" is a model that uses artificial intelligence technology to analyze data, generate feedback, and provide advice.

[0181] "Cause of error" refers to the underlying cause of a system failure or error.

[0182] "Solution" refers to specific methods and procedures for restoring the system to the identified cause of the error.

[0183] "Code" refers to the set of instructions and data that make up a program.

[0184] "Feedback" refers to information including evaluations and suggestions regarding code quality and optimization.

[0185] "Question or Request" refers to a question or request for specific information that a user makes to the system.

[0186] "Personalized advice" refers to specialized advice provided based on a user's individual history and context.

[0187] "Registration Information" refers to information such as name, email address, and password that a User enters to create a new Account.

[0188] "Encryption" refers to the process of transforming data to protect it from unauthorized access by third parties.

[0189] "Decoding" refers to the process of returning encrypted data to its original form.

[0190] "Secure storage" refers to storing data in a protected manner, such as in a database, to ensure its confidentiality, integrity, and availability.

[0191] This invention is a system that utilizes a generative AI model to automate the process from detecting system errors to analyzing their causes and planning countermeasures. The system receives error reports from users, analyzes the cause of the error based on the content of the reports, and presents appropriate solutions. It also receives requests for code reviews, analyzes the code, and provides feedback. It also provides personalized advice based on the user's past question history.

[0192] System configuration

[0193] User

[0194] Users use the terminal to enter reports of system outages and errors, as well as to enter requests for code reviews and advice, and to register new accounts.

[0195] Terminal

[0196] The terminal receives input from the user and sends it to the server. Examples of input data include prompts such as "There is a database connection error" or "Please tell me how to resolve the previous error."

[0197] server

[0198] The server receives error information, codes, and requests sent from the device, analyzes them using a generative AI model, and generates appropriate solutions, feedback, and advice, which are then sent to the device and presented to the user.

[0199] Error detection and analysis

[0200] Receiving error reports

[0201] The server receives the error report entered by the user into the terminal. For example, it receives specific error information such as "a database connection error has occurred."

[0202] Log collection and analysis

[0203] The server collects system and error logs based on the error report and analyzes the log data using a generative AI model. As a result of the analysis, it can identify that "the connection string may be incorrect."

[0204] Solution generation and presentation

[0205] Based on the analysis results, the server uses a generative AI model to generate an appropriate solution, such as "Please check your configuration file and correct the connection string."

[0206] Conducting code reviews

[0207] Enter and send the code

[0208] The user enters a code to request a review into the terminal and sends it to the server. For example, enter a code such as print("Hello World").

[0209] Code analysis and feedback

[0210] The server inputs the received code into a generative AI model, analyzes the code's quality and optimization points, and generates feedback such as "Consider changing this code to print(f'Hello World')."

[0211] Providing feedback

[0212] The generated feedback is sent to the terminal and presented to the user, who can then modify the code according to the presented feedback.

[0213] Providing personalized advice

[0214] Receiving a request

[0215] A user requests advice on a specific problem, for example, "Please tell me how to fix the last error."

[0216] Review and analyze historical data

[0217] The server reads the user's past question history and feedback from a database and uses a generative AI model to generate appropriate advice, such as "As before, check your configuration file and try a new connection string."

[0218] Providing advice

[0219] The generated advice is sent to the terminal and presented to the user, allowing the user to solve the problem efficiently.

[0220] Security measures

[0221] Entering and encrypting registration information

[0222] To create a new account, a user enters the necessary registration information (name, email address, password, etc.) into the device, which then encrypts this information and sends it to the server.

[0223] Decryption and storage of registration information

[0224] The server will properly decrypt the received registration information and store it securely in a database. The security of the registration information is guaranteed by using appropriate encryption technology and access control.

[0225] Displaying a confirmation message

[0226] The server generates and sends a confirmation message indicating successful account creation to the terminal, which displays this message to the user to confirm successful account creation.

[0227] In this way, the system of the present invention efficiently detects and quickly recovers from errors, improves code quality, provides tailored advice to users, and securely manages registration information. For example, the system can be used by inputting the following prompts into the generative AI model:

[0228] "I'm getting a database connection error. What's the cause and how can I fix it?"

[0229] "Please review the code print("Hello World")."

[0230] This allows users to receive prompt and appropriate support.

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

[0232] Step 1:

[0233] A user inputs information about a system failure or error into a terminal. For example, "A database connection error has occurred" and sends the input to the server. Input data: Error message. Output data: Error message sent to the server.

[0234] Step 2:

[0235] The server receives error messages sent from the terminal. It records the received error messages in a log file and collects system logs and error logs. Input data: Error messages. Output data: Collected log files.

[0236] Step 3:

[0237] The log data collected by the server is input into the generative AI model to analyze the cause of the error. The generative AI model is used to analyze the log data and identify the cause. For example, a result such as "The connection string may be incorrect" is obtained. Input data: Log data. Output data: Cause of the error.

[0238] Step 4:

[0239] Based on the cause of the error identified by the server, a generative AI model is used to generate an appropriate solution. For example, a message such as "Please check your configuration file and correct the connection string" is generated. Input data: Cause of the error. Output data: Solution message.

[0240] Step 5:

[0241] The server sends the generated solution to the terminal. The terminal receives the message and displays it to the user. The user follows the presented solution to check and correct the system settings. Input data: Solution message. Output data: Display to the user.

[0242] Step 6:

[0243] The user enters the code to be reviewed into the terminal. For example, enter the code print("Hello World"). The code is sent to the server. Input data: Code. Output data: Code sent to the server.

[0244] Step 7:

[0245] The server receives the code sent from the device and inputs it into a generative AI model to analyze the code. The model detects the quality of the code and points for optimization, and generates feedback. For example, it generates feedback such as "Consider changing this code to print(f'Hello World')." Input data: Code. Output data: Feedback.

[0246] Step 8:

[0247] The server generates feedback and sends it to the device. The device receives the feedback and displays it to the user. The user modifies their code based on this feedback. Input data: Feedback. Output data: Display to the user.

[0248] Step 9:

[0249] A user types a request into their terminal for personalized advice on a specific problem. For example, "Please tell me how to fix the last error." The request is sent to the server. Input data: Advice request. Output data: Request sent to the server.

[0250] Step 10:

[0251] The server receives the request and reads the user's past question history and feedback from a database. It uses a generative AI model to generate appropriate personalized advice. For example, it generates advice such as "As before, check your configuration file and try a new connection string." Input data: past question history and requests. Output data: personalized advice.

[0252] Step 11:

[0253] The server generates personalized advice and sends it to the device. The device receives the advice and displays it to the user. The user configures and operates the system according to the advice. Input data: personalized advice. Output data: display to the user.

[0254] Step 12:

[0255] A user enters registration information into a device to create a new account. For example, the user enters a name, email address, password, etc. The device encrypts the entered information and sends it to the server. Input data: Registration information. Output data: Encrypted registration information sent to the server.

[0256] Step 13:

[0257] The server receives the encrypted registration information, properly decrypts it, and stores it securely in a database. Encryption technology and access control are used to ensure the security of the information. Input data: Encrypted registration information. Output data: Information securely stored in a database.

[0258] Step 14:

[0259] The server generates a confirmation message indicating successful account creation and sends it to the terminal. The terminal receives the confirmation message and displays it to the user. The user confirms that account creation was successfully completed. Input data: Confirmation message. Output data: Displayed to the user.

[0260] (Application example 1)

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

[0262] In conventional systems, the detection and analysis of system failures and errors is done manually, which is time-consuming and requires specialized knowledge. Another problem is that it is difficult to quickly provide appropriate solutions when users encounter security-related errors. Furthermore, the mechanisms for providing personalized advice based on past questions and feedback are insufficient, preventing optimal support for individual users. It is necessary to solve these problems, reduce the burden on users, and improve the safety and efficiency of systems.

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

[0264] In this invention, the server includes means for receiving details of system failures and errors from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating a solution to the error based on the analysis results, means for presenting the generated solution to the error to the user, means for automatically notifying of a detected system failure, means for identifying the cause using a generative AI model based on log data, means for generating an appropriate solution based on the cause, and means for presenting the generated solution to the user. This automates the detection and analysis of system failures and errors, enables users to obtain quick and appropriate solutions, and can also provide personalized advice based on past question history, thereby improving the safety and efficiency of the system.

[0265] A "user" is a person or organization that uses the system.

[0266] A "system failure" is an event that disrupts the normal operation of a system and causes errors or malfunctions.

[0267] "Error details" refers to specific information reported by a user about a problem or malfunction related to a system failure.

[0268] An "error log" is information that shows records of errors that occur within the system.

[0269] A "generative AI model" is an artificial intelligence model that learns from large amounts of data and is used for analysis and generation.

[0270] "Analysis" is the process of examining given data or information in detail and making judgments.

[0271] A "Solution" is a specific technique or instruction for correcting or working around a specific problem or error.

[0272] A "means" is a method or device used to achieve a specific function or purpose within a system.

[0273] "Notification" refers to the act or means of informing a user of a specific event or information.

[0274] "Log data" refers to recorded data such as operation history and error information within the system.

[0275] "Cause" refers to the source or reason for a system failure or error.

[0276] A "solution" is a specific procedure or measure to resolve a specific problem or error.

[0277] "Question history" is a record of questions and inquiries that a user has made to the system in the past.

[0278] "Personalized advice" is advice that is tailored to the individual user based on their individual circumstances and history.

[0279] An "activity" is a series of operations or actions that a user performs when using a system.

[0280] To implement this invention, it is necessary to build a system that includes the following elements: The system receives error reports from users, analyzes them using a generative AI model, and proposes solutions. Furthermore, a security assistant app is installed on a smartphone and provides personalized advice based on the user's past question history and feedback.

[0281] System Hardware and Software

[0282] Hardware

[0283] Smartphone: iOS or Android device

[0284] Server: High-performance computer server, database server (e.g. MySQL, PostgreSQL)

[0285] software

[0286] Operating system: iOS or Android on the smartphone, Linux (e.g. Ubuntu) on the server

[0287] Generative AI model: OpenAI API

[0288] Log management software: Python logging module

[0289] Data analysis libraries: Python's standard library and additional libraries (e.g., Pandas, NumPy)

[0290] Detailed system description

[0291] 1. Receiving Error Reports

[0292] When a user reports a system failure or error, the smartphone app receives the details and sends them to the server, where the error message is stored along with the log data.

[0293] 2. Error Analysis

[0294] The server uses a generative AI model to analyze the received error messages and system logs. Specifically, it uses the OpenAI API to analyze the error messages and log data as input and identify the cause of the error.

[0295] 3. Providing a solution

[0296] After identifying the cause of the error, the server again uses the generative AI model to generate an appropriate solution. For example, it might generate specific instructions such as, "Check your firewall settings and block unauthorized access." The generated solution is then sent to the user's smartphone and presented to them.

[0297] 4. Personalized advice

[0298] Based on the user's previous questions and feedback, generative AI models are used to provide personalized advice that is tailored to the user's individual needs.

[0299] Specific examples

[0300] Use case 1: Reporting error messages and suggesting solutions

[0301] What the user does: Report the error message "Unauthorized access attempt detected."

[0302] Prompt sentence to input to the generative AI model:

[0303] Analyze the following error: Unauthorized access attempt detected and log data: {log_data}

[0304] Generated solution:

[0305] Check your device's firewall and ensure it is properly configured to block unauthorized access attempts.

[0306] Use case 2: Personalized advice

[0307] What users do: Ask for advice based on previous security questions.

[0308] Prompt sentence to input to the generative AI model:

[0309] Provide personalized security advice based on the user's past questions: How to secure my WiFi? Tips for safe online banking?

[0310] Generated advice:

[0311] To secure your WiFi, make sure to use a strong password, update your router firmware regularly, and use WPA3 encryption if available. For safe online banking, always use a secure and private internet connection, enable two-factor authentication, and regularly monitor your account for any suspicious activities.

[0312] The present invention allows users to obtain fast and accurate security measures and error resolution through an automated system, improving the safety and efficiency of the system.

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

[0314] Step 1: Receiving an error message

[0315] The terminal receives an error message as input from the user. For example, the user enters the message "Unauthorized access attempt detected." The terminal sends this error message to the server.

[0316] Input: User-supplied error message

[0317] Output: Sends an error message to the server

[0318] Step 2: Logging the error report

[0319] The server records the error message received from the terminal in a log file. Specifically, the error message is added to the error log.

[0320] Input: Error message

[0321] Output: Record the error message in the log data.

[0322] Step 3: Analyze the error message

[0323] The server inputs the log data and error messages into the generative AI model for analysis. The generative AI model (OpenAI API) analyzes the error messages and log data to identify the cause of the error.

[0324] Input: Log data, error message

[0325] Data processing: Generative AI models analyze log data and error messages

[0326] Output: Information about the cause of the error

[0327] Step 4: Generate a solution

[0328] The server inputs the cause of the error identified in step 3 into the generative AI model and generates an appropriate solution, for example, "Check your device's firewall and ensure it is properly configured to block unauthorized access attempts."

[0329] Input: Cause of error

[0330] Data processing: Generative AI models generate solutions

[0331] Output: Solution message

[0332] Step 5: Providing a solution

[0333] The server sends the generated solution to the terminal, and the terminal displays the solution to the user, allowing the user to know the specific countermeasure.

[0334] Input: Solution message

[0335] Output: Send the solution to the terminal and display it to the user

[0336] Step 6: Request personalized advice

[0337] The user requests advice based on past question history and feedback. For example, based on the history, the user enters a message such as "How to secure my WiFi?" into the device, requesting appropriate advice. The device then sends this request to the server.

[0338] Input: Advice request message

[0339] Output: Sends a request message to the server

[0340] Step 7: Review history and generate advice

[0341] The server checks the user's past question history and feedback, and uses a generative AI model to generate personalized advice, such as "To secure your WiFi, make sure to use a strong password..."

[0342] Input: User's past question history, feedback

[0343] Data processing: Generative AI models generate personalized advice

[0344] Output: Advice message

[0345] Step 8: Providing advice

[0346] The server transmits the generated personalized advice to the terminal, and the terminal displays the advice to the user, so that the user can act based on the specific advice.

[0347] Enter: personalized advice

[0348] Output: Sends advice to terminal and displays it to the user

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

[0350] This system receives information about system failures and errors from users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it responds according to the user's emotional state. This system automates the process from error detection to presenting solutions, improving user satisfaction.

[0351] Basic error analysis and solution presentation

[0352] 1. Receiving Error Reports

[0353] The user inputs the details of the system failure or error into the input screen of the terminal. For example, if the user reports that a database connection error has occurred, the terminal sends the details to the server.

[0354] 2. Error Analysis

[0355] Based on the error received by the server, the system log and error log are referenced. The server reads the log files and analyzes the relevant entries.

[0356] 3. Identifying the cause of the error

[0357] The server uses the generative AI model to analyze and identify the cause of the error, for example, "Your connection string may be incorrect."

[0358] 4. Solution Generation

[0359] Based on the analysis results, the server generates an appropriate solution using a generative AI model, such as a message saying, "Please check your configuration file and correct the connection string."

[0360] 5. Providing a solution

[0361] The server generates a solution message and sends it to the terminal, which displays it to the user. The user can follow the solution provided to check and correct the system settings.

[0362] An embodiment of error handling that combines an emotion engine

[0363] 6. Emotion Recognition Implementation

[0364] When a user inputs an error report, the device uses an emotion engine to recognize the user's emotions based on the user's facial expressions and voice. For example, it may determine that the user is feeling stressed.

[0365] 7. Emotion-Based Analysis

[0366] The server receives the recognized emotion information and uses it to further customize the analysis results of the generative AI model. For example, if a user is feeling stressed, it will provide a "specific and easy-to-understand step-by-step solution."

[0367] 8. Providing emotional solutions

[0368] The server generates a solution message based on the emotional information and sends it to the device, which then displays it to the user. For example, the message might say, "We'll start by explaining how to open the configuration file and then provide detailed instructions on how to modify the connection string."

[0369] Examples:

[0370] When a user reports a "database connection error," the device detects stress from the user's tone of voice and facial expression. The server recognizes this and generates a more detailed guide, which looks like this:

[0371] "When you open the configuration file, first check it using a text editor. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that the value is correct."

[0372] Code review support implementation example

[0373] 1. Enter and submit the code

[0374] The user enters a code into the terminal to request a review. Example: print("Hello World")

[0375] 2. Code Analysis

[0376] The device sends the code to the server, which then uses a generative AI model to analyze the code, for example, checking syntax and finding optimization points.

[0377] 3. Utilizing the Emotion Engine

[0378] The emotion engine also works during code reviews to recognize the user's emotional state, for example, shortening the feedback if the user is feeling tired.

[0379] 4. Generating and Presenting Feedback

[0380] The server generates appropriate feedback based on the analysis results and presents it to the user via the terminal. For example, feedback such as "Consider changing this code to print(f'Hello World')" is provided. The wording and content of the feedback are adjusted as necessary, taking into account emotional information.

[0381] Embodiments of personalized advice

[0382] 1. Request for advice

[0383] A user requests advice on a specific problem at the terminal, for example, by typing "Please tell me how to fix the last error."

[0384] 2. History Check and Emotion Recognition

[0385] The device sends an advice request to the server, which then refers to the user's past question history and feedback. At the same time, the emotion engine recognizes the user's emotional state.

[0386] 3. Generating and Presenting Advice

[0387] The server uses a generative AI model to generate appropriate advice based on historical data and the user's emotional state. Taking into account the user's emotional state, the server adjusts the content and presentation of the advice as needed. For example, the advice might be, "As before, check your configuration file and try a new connection string."

[0388] In this way, by combining emotion engines, it is possible to respond flexibly and appropriately according to the user's emotional state. The present invention not only improves error recovery speed but also improves user satisfaction.

[0389] The processing flow will be explained below.

[0390] Specific program processing for error handling that combines an emotion engine

[0391] Step 1:

[0392] The user enters the details of the system failure or error into the input screen of the terminal.

[0393] For example: "A database connection error has occurred."

[0394] Step 2:

[0395] The terminal transmits the error content input by the user to the server.

[0396] Step 3:

[0397] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[0398] Example: "User is feeling stressed"

[0399] Step 4:

[0400] The device transmits emotional state data to the server.

[0401] Step 5:

[0402] Based on the error content and emotion data received by the server, the system log and error log are referenced, and the log files are read and related entries are analyzed.

[0403] Step 6:

[0404] The server uses the generative AI model to analyze and identify the cause of the error.

[0405] For example: "Your connection string may be incorrect."

[0406] Step 7:

[0407] Based on the recognized emotion information, the server generates a solution including detailed guidance if the user is feeling stressed.

[0408] Example: "I'll start by explaining how to open the configuration file and then show you in detail how to modify the connection string."

[0409] Step 8:

[0410] Sends server-generated error resolution messages to the terminal.

[0411] Step 9:

[0412] The terminal displays the solution message received from the server to the user.

[0413] For example: "When you open the configuration file, first use a text editor to look at it. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that its value is correct."

[0414] Step 10:

[0415] The user checks and corrects the system settings according to the suggested solutions.

[0416] Specific program processing of emotion engine in code review support

[0417] Step 1:

[0418] The user pastes the code to request a review into the input screen of the device.

[0419] Example: print("Hello World")

[0420] Step 2:

[0421] The terminal sends the code entered by the user to the server.

[0422] Step 3:

[0423] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[0424] Example: "User is tired"

[0425] Step 4:

[0426] The device transmits emotional state data to the server.

[0427] Step 5:

[0428] The server inputs the received code into a generative AI model and performs syntax analysis of the code.

[0429] Step 6:

[0430] The server uses generative AI models to generate feedback on code quality and performance.

[0431] For example: "Consider this code to be print(f"Hello World")"

[0432] Step 7:

[0433] Based on the emotional information recognized by the server, the system adjusts the feedback, such as by simplifying it for tired users.

[0434] Step 8:

[0435] The server generates feedback and sends it to the device.

[0436] Step 9:

[0437] The terminal displays the feedback received from the server to the user.

[0438] Step 10:

[0439] The user modifies the code based on the feedback.

[0440] Specific program processing of emotion engine for personalized advice

[0441] Step 1:

[0442] A user requests advice on a particular problem at a terminal.

[0443] For example: "Please tell me how to resolve the previous error."

[0444] Step 2:

[0445] The terminal sends an advice request to the server.

[0446] Step 3:

[0447] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[0448] Example: "Users are feeling anxious"

[0449] Step 4:

[0450] The device transmits emotional state data to the server.

[0451] Step 5:

[0452] The server references the user's past question history and feedback database to obtain relevant information.

[0453] Step 6:

[0454] The server uses a generative AI model to generate advice based on past data.

[0455] For example: "As before, please check your configuration file and try a new connection string."

[0456] Step 7:

[0457] Based on the recognized emotional information, the server adjusts its advice to provide more polite and specific advice to users who are feeling anxious.

[0458] Step 8:

[0459] The server sends the generated advice to the terminal.

[0460] Step 9:

[0461] The terminal displays the advice received from the server to the user.

[0462] Step 10:

[0463] The user configures and operates the system based on the advice provided.

[0464] This system enables flexible and appropriate responses that take into account the user's emotional state, thereby improving error recovery speed and user satisfaction.

[0465] Example 2

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

[0467] In conventional systems, even when an error is reported by a user, it takes a long time to identify the cause and present a solution, which results in a decrease in user satisfaction. Furthermore, because the system is unable to respond flexibly and consider the user's emotional state, it is difficult to provide sufficient support, especially to users who are feeling stressed.

[0468] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for receiving details of a system failure or error from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating an error solution based on the analysis results, means for recognizing the emotional state of the user, means for customizing a solution based on the recognized emotional state, and means for presenting the generated error solution to the user. This enables quick processing from error detection to solution presentation and flexible response according to the user's emotional state.

[0469] "User" refers to a person or process that uses the system.

[0470] "Contents of system failures and errors" refers to detailed information about problems or abnormalities that prevent the system from functioning properly.

[0471] "Error log" refers to records and data regarding errors and failures that occur within a system.

[0472] A "generative AI model" is a model that uses machine learning and deep learning to learn patterns and knowledge from data and perform specific tasks.

[0473] "Cause of error" refers to the factors or underlying problems that cause a system failure or error.

[0474] "Error resolution" refers to specific steps or methods for correcting a detected error and restoring the system to a normal state.

[0475] "Emotional state" refers to the current emotional state of the user as determined from their facial expressions, voice, behavior, etc.

[0476] "Customizing the solution" refers to optimizing the error solution depending on the user's emotional state and situation.

[0477] This system receives information about system failures and errors from users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it responds according to the user's emotional state. This system automates the process from error detection to presenting solutions, improving user satisfaction.

[0478] The system of the present invention performs operations by assigning specific roles to the server, terminal, and user.

[0479] Receiving error reports

[0480] The user enters the details of a system failure or error into the input screen of the terminal. For example, a user may report that a database connection error has occurred. The terminal then sends this information to the server. A communication protocol such as an HTTP request is used for transmission.

[0481] Error Analysis

[0482] Based on the error content received by the server, the system log and error log are referenced. The server reads the log file from the specified path, extracts and analyzes the relevant entries, and uses text analysis algorithms and regular expressions for the analysis.

[0483] Identifying the cause of the error

[0484] The server uses a generative AI model to analyze and identify the cause of the error. For example, it provides an analysis result such as the possibility that the connection string is incorrect. This generative AI model has learned from past log data and error information, enabling it to identify the cause with high accuracy.

[0485] Solution Generation

[0486] Based on the analysis results, the server uses a generative AI model to generate an appropriate solution, such as a message like "Please check the configuration file and correct the connection string." The generated solution is presented to the user in an easy-to-understand format.

[0487] Providing a solution

[0488] The server sends the generated solution message to the device, usually via an HTTP response, and the device displays the received message to the user, for example, in a pop-up window or notification area.

[0489] Emotion Recognition in Action

[0490] When a user reports an error, the device uses a camera and microphone to capture the user's facial expressions and voice, and inputs this information into the emotion engine. The emotion engine then uses the collected data to recognize the user's emotional state. For example, it can determine that the user is feeling stressed.

[0491] Sentiment-based analysis and customized solutions

[0492] The server receives the emotional information sent from the emotion engine and customizes the analysis results of the generative AI model. Depending on the emotional state, the server generates the optimal solution for the user, such as by refining the details of the solution.

[0493] Specific examples

[0494] If the user reports a "database connection error" and the device detects stress from the user's tone of voice or facial expression, the server will recognize this and generate a detailed guide. The device will display:

[0495] "When you open the configuration file, first check it using a text editor. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that the value is correct."

[0496] In this way, the system of the present invention can quickly and efficiently detect errors and provide solutions, and it can also flexibly respond to the user's emotional state. It can also provide code reviews and personalized advice, improving the overall user experience.

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

[0498] Step 1:

[0499] Receiving error reports

[0500] The user enters details of the system failure or error into the input screen of the terminal. The input includes an error message such as "A database connection error has occurred."

[0501] The terminal sends the entered error content to the server. The HTTP request protocol is used for sending. The output is the data that arrives at the server as an HTTP request.

[0502] Step 2:

[0503] Receiving error details and analyzing logs

[0504] The system log and error log are queried based on the error content received by the server. The error content and the path to the target log file are included as input.

[0505] The server reads the log file, extracts relevant entries, and performs text analysis, specifically extracting error messages and error numbers from the log file. The output is a list of the extracted log entries.

[0506] Step 3:

[0507] Identifying the cause of the error

[0508] The server inputs the extracted log entries into a generative AI model to analyze the cause of the error. As input, a list of log entries is passed to the model.

[0509] The generative AI model uses patterns learned from past data to identify the cause of the error, specifically, "The connection string is likely incorrect." The output is a specific explanation of the cause of the error.

[0510] Step 4:

[0511] Solution Generation

[0512] Based on the analysis results, the server generates an appropriate solution using a generative AI model, with the identified error causes passed as input to the model.

[0513] The generative AI model generates a specific solution based on the cause of the error, for example, a message such as "Please check your configuration file and correct the connection string." The output is a solution message to present to the user.

[0514] Step 5:

[0515] Providing a solution

[0516] The server sends the generated solution message to the terminal, which includes the solution message as input.

[0517] The terminal displays the received message to the user. Specifically, the message is displayed in a pop-up window or notification area. The output is a solution message displayed on the user's screen.

[0518] Step 6:

[0519] Emotion Recognition in Action

[0520] When a user inputs an error report, the device uses a camera and microphone to collect the user's facial expressions and voice. The input includes the user's facial image and voice data.

[0521] The device inputs the collected data into an emotion engine to recognize the user's emotion. For example, it determines that the user is feeling stressed. The output is the recognized emotional state.

[0522] Step 7:

[0523] Sentiment-based analysis and customized solutions

[0524] The server receives the emotion information sent from the emotion engine and customizes the analysis results of the generative AI model. The inputs include the emotional state and the error analysis results.

[0525] Depending on the user's emotional state, the solution is customized by providing more detailed information. For example, a user who is feeling stressed can be provided with a specific, easy-to-understand, step-by-step solution. The output is a solution message customized based on the user's emotions.

[0526] Step 8:

[0527] Providing emotional solutions

[0528] The server sends a solution message that takes into account the emotion information to the terminal, and the customized solution message is included as input.

[0529] The terminal displays this message to the user in a specific and understandable manner, for example, by providing detailed step-by-step instructions. The output is a customized solution message displayed on the user's screen.

[0530] (Application example 2)

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

[0532] In security systems, the possibility of system failures and errors is unavoidable, but responding to them quickly and accurately is difficult. In particular, when a user encounters an error, it is necessary to immediately provide an appropriate solution. Furthermore, a user-friendly response is required, rather than one-sided support that ignores the user's emotional state. Therefore, a system is needed that reduces the stress and frustration users feel when solving errors and improves their satisfaction.

[0533] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving details of a system failure or error from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating an error solution based on the analysis results, means for presenting the generated error solution to the user, and emotion recognition means for recognizing the user's emotional state and customizing a response. This enables automation of error resolution and flexible responses according to the user's emotional state.

[0534] The "means for receiving details of system failures and errors from users" refers to the means for collecting system failures and error messages reported by users through a terminal or interface.

[0535] "Means for analyzing error logs based on received error content" refers to means for analyzing error reports received from users by referencing error log files of systems or software.

[0536] "Method of analyzing the cause of an error using a generative AI model" refers to a method of identifying the root cause of an error based on the analysis results of an error log, using a generative AI model that uses machine learning and deep learning.

[0537] "Means for generating solutions to errors based on analysis results" refers to means for automatically generating specific steps and measures for solving problems based on the results of analysis of the cause of an error by a generative AI model.

[0538] The "means for presenting the generated error solution to the user" refers to a means for notifying and displaying the generated solution to the user in an easy-to-understand manner.

[0539] "Emotion recognition means for recognizing a user's emotional state and customizing a response" refers to a means for analyzing a user's facial expressions and voice to recognize the user's emotional state and provide an appropriate solution or response according to the user's specific emotional state.

[0540] This invention is a system that receives system failures and errors reported by users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it is possible to respond according to the user's emotional state. This specification describes the form of an error analysis and support application for security systems.

[0541] The server first collects error reports from smartphones and other devices as a means of receiving details of system failures and errors from users. The collected error reports are sent to the server. The server then performs error log analysis based on the received error reports. This includes referencing system log files and analyzing the error conditions.

[0542] Next, the server uses a generative AI model to analyze the cause of the error. This generative AI model is based on machine learning and deep learning technologies, and is able to identify the cause with high accuracy by studying a large amount of past data. Once the cause of the error has been identified, the server generates an appropriate solution to the error based on the analysis results. This solution is generated automatically and provided to the user in an easy-to-understand manner.

[0543] The application also incorporates emotion recognition means to recognize the user's emotional state. This emotion recognition utilizes voice recognition software called "emotion_recognition" and machine learning models for emotion recognition. For example, it can determine whether the user is feeling stressed from their tone of voice and facial expression. Based on this information, the server presents customized solutions according to the user's emotional state. This allows for flexible responses tailored to the user's emotions, improving user satisfaction.

[0544] For example, if a user reports that a camera connection error has occurred, the server analyzes the error log and identifies the cause as a camera setting error. If the server recognizes that the user is feeling stressed, it provides a detailed and courteous solution, such as "Open the app's settings screen and check the camera connection settings. Detailed instructions are below..."

[0545] Example prompt sentence:

[0546] "Please receive error reports from users, identify the cause of camera connection errors, and provide detailed step-by-step solutions. Please also take into consideration the frustration expressed by users."

[0547] This system improves user satisfaction by automating error resolution and enabling flexible responses according to the user's emotional state. It also improves the reliability of the security system by providing fast and accurate support.

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

[0549] Step 1:

[0550] The user inputs the details of the system failure or error into their smartphone or device and sends it. For example, the input here is text such as "A camera connection error has occurred." The device then sends this error report to the server.

[0551] Step 2:

[0552] Based on the error report received by the server, the system log and error log are analyzed. The server reads the log file, extracts the log entry related to the reported error, and performs error log analysis. The results of this analysis become the data for the next process.

[0553] Step 3:

[0554] The server uses a generative AI model to identify the cause of the error from the results of error log analysis. The generative AI model is a model that has learned from past error analysis data, and outputs an estimate of the cause of the identified error. Specifically, the output may be a cause such as "mistake in connection settings."

[0555] Step 4:

[0556] The server uses the generative AI model to generate an appropriate solution to the error based on the analysis results. The AI ​​model generates a solution procedure corresponding to the identified cause of the error, such as "Open the app settings screen and check the camera connection settings."

[0557] Step 5:

[0558] When a user reports an error, the device collects the user's voice and facial expression data and uses emotion recognition to recognize the user's emotional state. Specifically, the "emotion_recognition" software analyzes the user's tone of voice and facial expression and outputs an emotional state such as stress or anxiety.

[0559] Step 6:

[0560] The server generates flexible solutions based on the user's emotions based on the emotion recognition results. For example, if the server detects that the user is feeling stressed, it will tailor the solution to provide a detailed step-by-step solution.

[0561] Step 7:

[0562] The server sends the generated solution to the terminal, which displays it to the user. The terminal displays the generated solution message to the user in a user-friendly format, allowing the user to take action.

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

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

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

[0566] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0579] This invention is a system that automates the process from detecting system errors to analyzing their causes and planning countermeasures. The system utilizes a generative AI model to analyze errors based on user reports and propose appropriate solutions. It also provides code reviews and personalized advice.

[0580] Interactive Debugging Implementation

[0581] 1. Receiving Error Reports

[0582] A user inputs a system failure or error into a terminal. For example, if a user reports that a database connection error has occurred, the terminal sends the information to the server.

[0583] 2. Error Analysis

[0584] The server analyzes system logs and error logs based on the error reports received from users. A generative AI model analyzes the log data and identifies the cause of the error, such as "The connection string may be incorrect."

[0585] 3. Providing a solution

[0586] Based on the cause of the error analyzed by the server, the generative AI model generates an appropriate solution. For example, it generates a message such as "Please check the configuration file and correct the connection string" and presents it to the user via the terminal. The user then follows the suggested solution to check and correct the system settings.

[0587] Code review support implementation example

[0588] 1. Enter and submit the code

[0589] The user enters a code to request a review into the terminal. For example, the code print("Hello World") is entered, and the terminal sends the code to the server.

[0590] 2. Code Analysis

[0591] The server analyzes the received code using a generative AI model. The model detects code quality and optimization points and generates feedback, such as "Consider changing this code to print(f'Hello World')."

[0592] 3. Providing feedback

[0593] The server generates feedback and sends it to the device, which displays it to the user, who can then modify their code based on the feedback.

[0594] Embodiments of personalized advice

[0595] 1. Request for advice

[0596] A user requests advice on a specific problem, for example, "Please tell me how to fix the last error," by typing the request into the terminal and sending it to the server.

[0597] 2. Check and analyze history

[0598] The server then references the user's past question history and feedback, and generates appropriate advice based on the generative AI model. Based on information extracted from past data, the server provides specific advice such as "Check your configuration file and try a new connection string, just like last time."

[0599] 3. Providing advice

[0600] The server sends the generated advice to the terminal, which displays it to the user, who then configures and operates the system based on the advice.

[0601] Learning and teaching practices

[0602] 1. Enter and submit your question

[0603] The user types a question about a new programming language or framework into the terminal, for example, "What is a generator in Python?", which the terminal then sends to the server.

[0604] 2. Question Analysis and Answer Generation

[0605] The server inputs the received question into a generative AI model for analysis. The model understands the intent of the question and generates an appropriate answer. For example, it generates an answer such as "A generator is a method for easily creating an iterator, and uses the yield keyword."

[0606] 3. Presenting the Answer

[0607] The server generates answers and sends them to the device, which displays them to the user, who can use the information to deepen their understanding of programming languages ​​and frameworks.

[0608] Implementation of security measures

[0609] 1. Entering and Encrypting Registration Information

[0610] A user enters registration information to create a new account into the device, such as a name, email address, and password, which the device then encrypts and sends to the server.

[0611] 2. Secure Data Storage

[0612] The server will then properly decrypt the registration information received and store it securely in a database, decrypting the encrypted data and applying access controls to prevent unauthorized access.

[0613] 3. Confirmation message displayed

[0614] The server sends a confirmation message to the terminal indicating the completion of the account creation, which the terminal displays to the user. The user receives the confirmation message and confirms that the account creation was successfully completed.

[0615] In this way, the system of the present invention automates the process from error detection to cause analysis and countermeasure planning, reducing the workload of system personnel and improving the speed of error recovery.

[0616] The processing flow will be explained below.

[0617] Specific program processing for interactive debugging

[0618] Step 1:

[0619] The user enters the details of the system failure or error into the input screen of the terminal.

[0620] For example: "A database connection error has occurred."

[0621] Step 2:

[0622] The terminal transmits the error content input by the user to the server.

[0623] Step 3:

[0624] Based on the error content received by the server, the system log and error log are referenced.

[0625] Step 4:

[0626] The server reads the log file and parses it for entries related to the error.

[0627] Step 5:

[0628] The server uses the generated AI model to match the log data with the error content and identify the cause of the error.

[0629] For example: "Your connection string may be incorrect."

[0630] Step 6:

[0631] The server generates a solution to the error based on the analysis results.

[0632] For example: "Please check your configuration file and correct your connection string."

[0633] Step 7:

[0634] The server sends the generated solution message to the terminal.

[0635] Step 8:

[0636] The terminal displays the solution message received from the server to the user.

[0637] Step 9:

[0638] The user tries the suggested solutions and checks and corrects system settings.

[0639] Specific program processing for code review support

[0640] Step 1:

[0641] The user pastes the code to request a review into the input screen of the device.

[0642] Example: print("Hello World")

[0643] Step 2:

[0644] The terminal sends the code entered by the user to the server.

[0645] Step 3:

[0646] The server inputs the received code into the generative AI model.

[0647] Step 4:

[0648] The server runs a syntactic analysis of the code through a generative AI model.

[0649] Step 5:

[0650] The server uses generative AI models to generate feedback on code quality and performance.

[0651] For example: "Consider this code to be print(f"Hello World")"

[0652] Step 6:

[0653] The server generates feedback and sends it to the device.

[0654] Step 7:

[0655] The terminal displays the feedback received from the server to the user.

[0656] Step 8:

[0657] The user modifies the code based on the feedback.

[0658] Specific programmatic processing of personalized advice

[0659] Step 1:

[0660] A user requests personalized advice on a particular issue at the device.

[0661] For example: "Please tell me how to resolve the previous error."

[0662] Step 2:

[0663] The terminal sends an advice request to the server.

[0664] Step 3:

[0665] The server references the user's past question history and feedback database to obtain relevant information.

[0666] Example: Previous question "Database connection error"

[0667] Step 4:

[0668] The server uses a generative AI model to generate solutions based on historical data.

[0669] Step 5:

[0670] The server generates specific and appropriate advice.

[0671] For example: "As before, please check your configuration file and try a new connection string."

[0672] Step 6:

[0673] The server sends the generated advice to the terminal.

[0674] Step 7:

[0675] The terminal displays the advice received from the server to the user.

[0676] Step 8:

[0677] The user configures and operates the system based on the advice provided.

[0678] Specific program processing for learning and teaching

[0679] Step 1:

[0680] The user types a question about a new programming language or framework into the terminal.

[0681] For example: "What is a generator in Python?"

[0682] Step 2:

[0683] The device sends the question to the server.

[0684] Step 3:

[0685] The server inputs the received questions into a generative AI model for analysis.

[0686] Step 4:

[0687] The server uses a generative AI model to generate an appropriate answer.

[0688] For example: "Generators are methods that make iterators easier to create, and they use the yield keyword."

[0689] Step 5:

[0690] The server generates a response and sends it to the terminal.

[0691] Step 6:

[0692] The terminal displays the answer received from the server to the user.

[0693] Step 7:

[0694] Users can deepen their understanding of programming languages ​​and frameworks based on the information provided.

[0695] Specific program processing for security measures

[0696] Step 1:

[0697] The user enters registration information into the terminal to create a new account.

[0698] For example: Name, email address, password

[0699] Step 2:

[0700] The terminal encrypts the entered registration information and transmits it to the server.

[0701] Step 3:

[0702] The server properly decrypts the encrypted data to store the received registration information in a database.

[0703] Step 4:

[0704] The server enforces access control and security policies on user data.

[0705] Step 5:

[0706] The server sends a confirmation message to the device indicating that the account creation is complete.

[0707] Step 6:

[0708] The terminal displays to the user the confirmation message received from the server.

[0709] Step 7:

[0710] The user receives the provided confirmation message, confirming successful account creation.

[0711] Example 1

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

[0713] There is a need to automate the process from error detection to cause analysis and response planning, reducing the workload of system personnel while improving error recovery speed. There is also a need to provide code reviews to improve system quality and personalized advice based on users' past question history. Furthermore, from a security standpoint, secure management of user registration information is also essential.

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

[0715] In this invention, the server includes means for receiving failure or error information from a user, means for analyzing logs based on the received error information, means for identifying the cause of the error using a generative AI model, means for generating a solution to the error based on the identified cause, means for presenting the generated solution to the error to the user, means for receiving code from the user and analyzing the code using a generative AI model to generate feedback, means for presenting the generated feedback to the user, means for receiving user questions or requests and generating personalized advice based on past data using a generative AI model, means for presenting the generated advice to the user, means for receiving user registration information, appropriately encrypting it, and transmitting it to the server, and means for appropriately decoding the received information and securely storing it. This enables efficient error detection and rapid recovery, improved code quality, provision of advice tailored to the user, and secure management of registration information.

[0716] A "user" is someone who uses the system to report errors, request code reviews, or request advice.

[0717] "Terminal" means an electronic device used by a user to enter fault or error information, codes, advice requests, registration information, etc.

[0718] A "server" is a computer system that receives information sent from a terminal and uses a generative AI model to analyze and generate solutions.

[0719] "Failure or error information" refers to detailed information or messages regarding system failures or errors.

[0720] A "log" is a collection of data that records the system's operating status, error messages, etc.

[0721] A "generative AI model" is a model that uses artificial intelligence technology to analyze data, generate feedback, and provide advice.

[0722] "Cause of error" refers to the underlying cause of a system failure or error.

[0723] "Solution" refers to specific methods and procedures for restoring the system to the identified cause of the error.

[0724] "Code" refers to the set of instructions and data that make up a program.

[0725] "Feedback" refers to information including evaluations and suggestions regarding code quality and optimization.

[0726] "Question or Request" refers to a question or request for specific information that a user makes to the system.

[0727] "Personalized advice" refers to specialized advice provided based on a user's individual history and context.

[0728] "Registration Information" refers to information such as name, email address, and password that a User enters to create a new Account.

[0729] "Encryption" refers to the process of transforming data to protect it from unauthorized access by third parties.

[0730] "Decoding" refers to the process of returning encrypted data to its original form.

[0731] "Secure storage" refers to storing data in a protected manner, such as in a database, to ensure its confidentiality, integrity, and availability.

[0732] This invention is a system that utilizes a generative AI model to automate the process from detecting system errors to analyzing their causes and planning countermeasures. The system receives error reports from users, analyzes the cause of the error based on the content of the reports, and presents appropriate solutions. It also receives requests for code reviews, analyzes the code, and provides feedback. It also provides personalized advice based on the user's past question history.

[0733] System configuration

[0734] User

[0735] Users use the terminal to enter reports of system outages and errors, as well as to enter requests for code reviews and advice, and to register new accounts.

[0736] Terminal

[0737] The terminal receives input from the user and sends it to the server. Examples of input data include prompts such as "There is a database connection error" or "Please tell me how to resolve the previous error."

[0738] server

[0739] The server receives error information, codes, and requests sent from the device, analyzes them using a generative AI model, and generates appropriate solutions, feedback, and advice, which are then sent to the device and presented to the user.

[0740] Error detection and analysis

[0741] Receiving error reports

[0742] The server receives the error report entered by the user into the terminal. For example, it receives specific error information such as "a database connection error has occurred."

[0743] Log collection and analysis

[0744] The server collects system and error logs based on the error report and analyzes the log data using a generative AI model. As a result of the analysis, it can identify that "the connection string may be incorrect."

[0745] Solution generation and presentation

[0746] Based on the analysis results, the server uses a generative AI model to generate an appropriate solution, such as "Please check your configuration file and correct the connection string."

[0747] Conducting code reviews

[0748] Enter and send the code

[0749] The user enters a code to request a review into the terminal and sends it to the server. For example, enter a code such as print("Hello World").

[0750] Code analysis and feedback

[0751] The server inputs the received code into a generative AI model, analyzes the code's quality and optimization points, and generates feedback such as "Consider changing this code to print(f'Hello World')."

[0752] Providing feedback

[0753] The generated feedback is sent to the terminal and presented to the user, who can then modify the code according to the presented feedback.

[0754] Providing personalized advice

[0755] Receiving a request

[0756] A user requests advice on a specific problem, for example, "Please tell me how to fix the last error."

[0757] Review and analyze historical data

[0758] The server reads the user's past question history and feedback from a database and uses a generative AI model to generate appropriate advice, such as "As before, check your configuration file and try a new connection string."

[0759] Providing advice

[0760] The generated advice is sent to the terminal and presented to the user, allowing the user to solve the problem efficiently.

[0761] Security measures

[0762] Entering and encrypting registration information

[0763] To create a new account, a user enters the necessary registration information (name, email address, password, etc.) into the device, which then encrypts this information and sends it to the server.

[0764] Decryption and storage of registration information

[0765] The server will properly decrypt the received registration information and store it securely in a database. The security of the registration information is guaranteed by using appropriate encryption technology and access control.

[0766] Displaying a confirmation message

[0767] The server generates and sends a confirmation message indicating successful account creation to the terminal, which displays this message to the user to confirm successful account creation.

[0768] In this way, the system of the present invention efficiently detects and quickly recovers from errors, improves code quality, provides tailored advice to users, and securely manages registration information. For example, the system can be used by inputting the following prompts into the generative AI model:

[0769] "I'm getting a database connection error. What's the cause and how can I fix it?"

[0770] "Please review the code print("Hello World")."

[0771] This allows users to receive prompt and appropriate support.

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

[0773] Step 1:

[0774] A user inputs information about a system failure or error into a terminal. For example, "A database connection error has occurred" and sends the input to the server. Input data: Error message. Output data: Error message sent to the server.

[0775] Step 2:

[0776] The server receives error messages sent from the terminal. It records the received error messages in a log file and collects system logs and error logs. Input data: Error messages. Output data: Collected log files.

[0777] Step 3:

[0778] The log data collected by the server is input into the generative AI model to analyze the cause of the error. The generative AI model is used to analyze the log data and identify the cause. For example, a result such as "The connection string may be incorrect" is obtained. Input data: Log data. Output data: Cause of the error.

[0779] Step 4:

[0780] Based on the cause of the error identified by the server, a generative AI model is used to generate an appropriate solution. For example, a message such as "Please check your configuration file and correct the connection string" is generated. Input data: Cause of the error. Output data: Solution message.

[0781] Step 5:

[0782] The server sends the generated solution to the terminal. The terminal receives the message and displays it to the user. The user follows the presented solution to check and correct the system settings. Input data: Solution message. Output data: Display to the user.

[0783] Step 6:

[0784] The user enters the code to be reviewed into the terminal. For example, enter the code print("Hello World"). The code is sent to the server. Input data: Code. Output data: Code sent to the server.

[0785] Step 7:

[0786] The server receives the code sent from the device and inputs it into a generative AI model to analyze the code. The model detects the quality of the code and points for optimization, and generates feedback. For example, it generates feedback such as "Consider changing this code to print(f'Hello World')." Input data: Code. Output data: Feedback.

[0787] Step 8:

[0788] The server generates feedback and sends it to the device. The device receives the feedback and displays it to the user. The user modifies their code based on this feedback. Input data: Feedback. Output data: Display to the user.

[0789] Step 9:

[0790] A user types a request into their terminal for personalized advice on a specific problem. For example, "Please tell me how to fix the last error." The request is sent to the server. Input data: Advice request. Output data: Request sent to the server.

[0791] Step 10:

[0792] The server receives the request and reads the user's past question history and feedback from a database. It uses a generative AI model to generate appropriate personalized advice. For example, it generates advice such as "As before, check your configuration file and try a new connection string." Input data: past question history and requests. Output data: personalized advice.

[0793] Step 11:

[0794] The server generates personalized advice and sends it to the device. The device receives the advice and displays it to the user. The user configures and operates the system according to the advice. Input data: personalized advice. Output data: display to the user.

[0795] Step 12:

[0796] A user enters registration information into a device to create a new account. For example, the user enters a name, email address, password, etc. The device encrypts the entered information and sends it to the server. Input data: Registration information. Output data: Encrypted registration information sent to the server.

[0797] Step 13:

[0798] The server receives the encrypted registration information, properly decrypts it, and stores it securely in a database. Encryption technology and access control are used to ensure the security of the information. Input data: Encrypted registration information. Output data: Information securely stored in a database.

[0799] Step 14:

[0800] The server generates a confirmation message indicating successful account creation and sends it to the terminal. The terminal receives the confirmation message and displays it to the user. The user confirms that account creation was successfully completed. Input data: Confirmation message. Output data: Displayed to the user.

[0801] (Application example 1)

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

[0803] In conventional systems, the detection and analysis of system failures and errors is done manually, which is time-consuming and requires specialized knowledge. Another problem is that it is difficult to quickly provide appropriate solutions when users encounter security-related errors. Furthermore, the mechanisms for providing personalized advice based on past questions and feedback are insufficient, preventing optimal support for individual users. It is necessary to solve these problems, reduce the burden on users, and improve the safety and efficiency of systems.

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

[0805] In this invention, the server includes means for receiving details of system failures and errors from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating a solution to the error based on the analysis results, means for presenting the generated solution to the error to the user, means for automatically notifying of a detected system failure, means for identifying the cause using a generative AI model based on log data, means for generating an appropriate solution based on the cause, and means for presenting the generated solution to the user. This automates the detection and analysis of system failures and errors, enables users to obtain quick and appropriate solutions, and can also provide personalized advice based on past question history, thereby improving the safety and efficiency of the system.

[0806] A "user" is a person or organization that uses the system.

[0807] A "system failure" is an event that disrupts the normal operation of a system and causes errors or malfunctions.

[0808] "Error details" refers to specific information reported by a user about a problem or malfunction related to a system failure.

[0809] An "error log" is information that shows records of errors that occur within the system.

[0810] A "generative AI model" is an artificial intelligence model that learns from large amounts of data and is used for analysis and generation.

[0811] "Analysis" is the process of examining given data or information in detail and making judgments.

[0812] A "Solution" is a specific technique or instruction for correcting or working around a specific problem or error.

[0813] A "means" is a method or device used to achieve a specific function or purpose within a system.

[0814] "Notification" refers to the act or means of informing a user of a specific event or information.

[0815] "Log data" refers to recorded data such as operation history and error information within the system.

[0816] "Cause" refers to the source or reason for a system failure or error.

[0817] A "solution" is a specific procedure or measure to resolve a specific problem or error.

[0818] "Question history" is a record of questions and inquiries that a user has made to the system in the past.

[0819] "Personalized advice" is advice that is tailored to the individual user based on their individual circumstances and history.

[0820] An "activity" is a series of operations or actions that a user performs when using a system.

[0821] To implement this invention, it is necessary to build a system that includes the following elements: The system receives error reports from users, analyzes them using a generative AI model, and proposes solutions. Furthermore, a security assistant app is installed on a smartphone and provides personalized advice based on the user's past question history and feedback.

[0822] System Hardware and Software

[0823] Hardware

[0824] Smartphone: iOS or Android device

[0825] Server: High-performance computer server, database server (e.g. MySQL, PostgreSQL)

[0826] software

[0827] Operating system: iOS or Android on the smartphone, Linux (e.g. Ubuntu) on the server

[0828] Generative AI Model: OpenAI API

[0829] Log management software: Python logging module

[0830] Data analysis libraries: Python's standard library and additional libraries (e.g., Pandas, NumPy)

[0831] Detailed system description

[0832] 1. Receiving Error Reports

[0833] When a user reports a system failure or error, the smartphone app receives the details and sends them to the server, where the error message is stored along with the log data.

[0834] 2. Error Analysis

[0835] The server uses a generative AI model to analyze the received error messages and system logs. Specifically, it uses the OpenAI API to analyze the error messages and log data as input and identify the cause of the error.

[0836] 3. Providing a solution

[0837] After identifying the cause of the error, the server again uses the generative AI model to generate an appropriate solution. For example, it might generate specific instructions such as, "Check your firewall settings and block unauthorized access." The generated solution is then sent to the user's smartphone and presented to them.

[0838] 4. Personalized advice

[0839] Based on the user's previous questions and feedback, generative AI models are used to provide personalized advice that is tailored to the user's individual needs.

[0840] Specific examples

[0841] Use case 1: Reporting error messages and suggesting solutions

[0842] What the user does: Report the error message "Unauthorized access attempt detected."

[0843] Prompt sentence to input to the generative AI model:

[0844] Analyze the following error: Unauthorized access attempt detected and log data: {log_data}

[0845] Generated solution:

[0846] Check your device's firewall and ensure it is properly configured to block unauthorized access attempts.

[0847] Use case 2: Personalized advice

[0848] What users do: Ask for advice based on previous security questions.

[0849] Prompt sentence to input to the generative AI model:

[0850] Provide personalized security advice based on the user's past questions: How to secure my WiFi? Tips for safe online banking?

[0851] Generated advice:

[0852] To secure your WiFi, make sure to use a strong password, update your router firmware regularly, and use WPA3 encryption if available. For safe online banking, always use a secure and private internet connection, enable two-factor authentication, and regularly monitor your account for any suspicious activities.

[0853] The present invention allows users to obtain fast and accurate security measures and error resolution through an automated system, improving the safety and efficiency of the system.

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

[0855] Step 1: Receiving an error message

[0856] The terminal receives an error message as input from the user. For example, the user enters the message "Unauthorized access attempt detected." The terminal sends this error message to the server.

[0857] Input: User-supplied error message

[0858] Output: Sends an error message to the server

[0859] Step 2: Logging the error report

[0860] The server records the error message received from the terminal in a log file. Specifically, the error message is added to the error log.

[0861] Input: Error message

[0862] Output: Record the error message in the log data.

[0863] Step 3: Analyze the error message

[0864] The server inputs the log data and error messages into the generative AI model for analysis. The generative AI model (OpenAI API) analyzes the error messages and log data to identify the cause of the error.

[0865] Input: Log data, error message

[0866] Data processing: Generative AI models analyze log data and error messages

[0867] Output: Information about the cause of the error

[0868] Step 4: Generate a solution

[0869] The server inputs the cause of the error identified in step 3 into the generative AI model and generates an appropriate solution, for example, "Check your device's firewall and ensure it is properly configured to block unauthorized access attempts."

[0870] Input: Cause of error

[0871] Data processing: Generative AI models generate solutions

[0872] Output: Solution message

[0873] Step 5: Providing a solution

[0874] The server sends the generated solution to the terminal, and the terminal displays the solution to the user, allowing the user to know the specific countermeasure.

[0875] Input: Solution message

[0876] Output: Send the solution to the terminal and display it to the user

[0877] Step 6: Request personalized advice

[0878] The user requests advice based on past question history and feedback. For example, based on the history, the user enters a message such as "How to secure my WiFi?" into the device, requesting appropriate advice. The device then sends this request to the server.

[0879] Input: Advice request message

[0880] Output: Sends a request message to the server

[0881] Step 7: Review history and generate advice

[0882] The server checks the user's past question history and feedback, and uses a generative AI model to generate personalized advice, such as "To secure your WiFi, make sure to use a strong password..."

[0883] Input: User's past question history, feedback

[0884] Data processing: Generative AI models generate personalized advice

[0885] Output: Advice message

[0886] Step 8: Providing advice

[0887] The server transmits the generated personalized advice to the terminal, and the terminal displays the advice to the user, so that the user can act based on the specific advice.

[0888] Enter: personalized advice

[0889] Output: Sends advice to terminal and displays it to the user

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

[0891] This system receives information about system failures and errors from users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it responds according to the user's emotional state. This system automates the process from error detection to presenting solutions, improving user satisfaction.

[0892] Basic error analysis and solution presentation

[0893] 1. Receiving Error Reports

[0894] The user inputs the details of the system failure or error into the input screen of the terminal. For example, if the user reports that a database connection error has occurred, the terminal sends the details to the server.

[0895] 2. Error Analysis

[0896] Based on the error received by the server, the system log and error log are referenced. The server reads the log files and analyzes the relevant entries.

[0897] 3. Identifying the cause of the error

[0898] The server uses the generative AI model to analyze and identify the cause of the error, for example, "Your connection string may be incorrect."

[0899] 4. Solution Generation

[0900] Based on the analysis results, the server generates an appropriate solution using a generative AI model, such as a message saying, "Please check your configuration file and correct the connection string."

[0901] 5. Providing a solution

[0902] The server generates a solution message and sends it to the terminal, which displays it to the user. The user can follow the solution provided to check and correct the system settings.

[0903] An embodiment of error handling that combines an emotion engine

[0904] 6. Emotion Recognition Implementation

[0905] When a user inputs an error report, the device uses an emotion engine to recognize the user's emotions based on the user's facial expressions and voice. For example, it may determine that the user is feeling stressed.

[0906] 7. Emotion-Based Analysis

[0907] The server receives the recognized emotion information and uses it to further customize the analysis results of the generative AI model. For example, if a user is feeling stressed, it will provide a "specific and easy-to-understand step-by-step solution."

[0908] 8. Providing emotional solutions

[0909] The server generates a solution message based on the emotional information and sends it to the device, which then displays it to the user. For example, the message might say, "We'll start by explaining how to open the configuration file and then provide detailed instructions on how to modify the connection string."

[0910] Examples:

[0911] When a user reports a "database connection error," the device detects stress from the user's tone of voice and facial expression. The server recognizes this and generates a more detailed guide, which looks like this:

[0912] "When you open the configuration file, first check it using a text editor. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that the value is correct."

[0913] Code review support implementation example

[0914] 1. Enter and submit the code

[0915] The user enters a code into the terminal to request a review. Example: print("Hello World")

[0916] 2. Code Analysis

[0917] The device sends the code to the server, which then uses a generative AI model to analyze the code, for example, checking syntax and finding optimization points.

[0918] 3. Utilizing the Emotion Engine

[0919] The emotion engine also works during code reviews to recognize the user's emotional state, for example, shortening the feedback if the user is feeling tired.

[0920] 4. Generating and Presenting Feedback

[0921] The server generates appropriate feedback based on the analysis results and presents it to the user via the terminal. For example, feedback such as "Consider changing this code to print(f'Hello World')" is provided. The wording and content of the feedback are adjusted as necessary, taking into account emotional information.

[0922] Embodiments of personalized advice

[0923] 1. Request for advice

[0924] A user requests advice on a specific problem at the terminal, for example, by typing "Please tell me how to fix the last error."

[0925] 2. History Check and Emotion Recognition

[0926] The device sends an advice request to the server, which then refers to the user's past question history and feedback. At the same time, the emotion engine recognizes the user's emotional state.

[0927] 3. Generating and Presenting Advice

[0928] The server uses a generative AI model to generate appropriate advice based on historical data and the user's emotional state. Taking into account the user's emotional state, the server adjusts the content and presentation of the advice as needed. For example, the advice might be, "As before, check your configuration file and try a new connection string."

[0929] In this way, by combining emotion engines, it is possible to respond flexibly and appropriately according to the user's emotional state. The present invention not only improves error recovery speed but also improves user satisfaction.

[0930] The processing flow will be explained below.

[0931] Specific program processing for error handling that combines an emotion engine

[0932] Step 1:

[0933] The user enters the details of the system failure or error into the input screen of the terminal.

[0934] For example: "A database connection error has occurred."

[0935] Step 2:

[0936] The terminal transmits the error content input by the user to the server.

[0937] Step 3:

[0938] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[0939] Example: "User is feeling stressed"

[0940] Step 4:

[0941] The device transmits emotional state data to the server.

[0942] Step 5:

[0943] Based on the error content and emotion data received by the server, the system log and error log are referenced, and the log files are read and related entries are analyzed.

[0944] Step 6:

[0945] The server uses the generative AI model to analyze and identify the cause of the error.

[0946] For example: "Your connection string may be incorrect."

[0947] Step 7:

[0948] Based on the recognized emotion information, the server generates a solution including detailed guidance if the user is feeling stressed.

[0949] Example: "I'll start by explaining how to open the configuration file and then show you in detail how to modify the connection string."

[0950] Step 8:

[0951] Sends server-generated error resolution messages to the terminal.

[0952] Step 9:

[0953] The terminal displays the solution message received from the server to the user.

[0954] For example: "When you open the configuration file, first use a text editor to look at it. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that its value is correct."

[0955] Step 10:

[0956] The user checks and corrects the system settings according to the suggested solutions.

[0957] Specific program processing of emotion engine in code review support

[0958] Step 1:

[0959] The user pastes the code to request a review into the input screen of the device.

[0960] Example: print("Hello World")

[0961] Step 2:

[0962] The terminal sends the code entered by the user to the server.

[0963] Step 3:

[0964] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[0965] Example: "User is tired"

[0966] Step 4:

[0967] The device transmits emotional state data to the server.

[0968] Step 5:

[0969] The server inputs the received code into a generative AI model and performs syntax analysis of the code.

[0970] Step 6:

[0971] The server uses generative AI models to generate feedback on code quality and performance.

[0972] For example: "Consider this code to be print(f"Hello World")"

[0973] Step 7:

[0974] Based on the emotional information recognized by the server, the system adjusts the feedback, such as by simplifying it for tired users.

[0975] Step 8:

[0976] The server generates feedback and sends it to the device.

[0977] Step 9:

[0978] The terminal displays the feedback received from the server to the user.

[0979] Step 10:

[0980] The user modifies the code based on the feedback.

[0981] Specific program processing of emotion engine for personalized advice

[0982] Step 1:

[0983] A user requests advice on a particular problem at a terminal.

[0984] For example: "Please tell me how to resolve the previous error."

[0985] Step 2:

[0986] The terminal sends an advice request to the server.

[0987] Step 3:

[0988] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[0989] Example: "Users are feeling anxious"

[0990] Step 4:

[0991] The device transmits emotional state data to the server.

[0992] Step 5:

[0993] The server references the user's past question history and feedback database to obtain relevant information.

[0994] Step 6:

[0995] The server uses a generative AI model to generate advice based on past data.

[0996] For example: "As before, please check your configuration file and try a new connection string."

[0997] Step 7:

[0998] Based on the recognized emotional information, the server adjusts its advice to provide more polite and specific advice to users who are feeling anxious.

[0999] Step 8:

[1000] The server sends the generated advice to the terminal.

[1001] Step 9:

[1002] The terminal displays the advice received from the server to the user.

[1003] Step 10:

[1004] The user configures and operates the system based on the advice provided.

[1005] This system enables flexible and appropriate responses that take into account the user's emotional state, thereby improving error recovery speed and user satisfaction.

[1006] Example 2

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

[1008] In conventional systems, even when an error is reported by a user, it takes a long time to identify the cause and present a solution, which results in a decrease in user satisfaction. Furthermore, because the system is unable to respond flexibly and consider the user's emotional state, it is difficult to provide sufficient support, especially to users who are feeling stressed.

[1009] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for receiving details of a system failure or error from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating an error solution based on the analysis results, means for recognizing the emotional state of the user, means for customizing a solution based on the recognized emotional state, and means for presenting the generated error solution to the user. This enables quick processing from error detection to solution presentation and flexible response according to the user's emotional state.

[1010] "User" refers to a person or process that uses the system.

[1011] "Contents of system failures and errors" refers to detailed information about problems or abnormalities that prevent the system from functioning properly.

[1012] "Error log" refers to records and data regarding errors and failures that occur within a system.

[1013] A "generative AI model" is a model that uses machine learning and deep learning to learn patterns and knowledge from data and perform specific tasks.

[1014] "Cause of error" refers to the factors or underlying problems that cause a system failure or error.

[1015] "Error resolution" refers to specific steps or methods for correcting a detected error and restoring the system to a normal state.

[1016] "Emotional state" refers to the current emotional state of the user as determined from their facial expressions, voice, behavior, etc.

[1017] "Customizing the solution" refers to optimizing the error solution depending on the user's emotional state and situation.

[1018] This system receives information about system failures and errors from users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it responds according to the user's emotional state. This system automates the process from error detection to presenting solutions, improving user satisfaction.

[1019] The system of the present invention performs operations by assigning specific roles to the server, terminal, and user.

[1020] Receiving error reports

[1021] The user enters the details of a system failure or error into the input screen of the terminal. For example, a user may report that a database connection error has occurred. The terminal then sends this information to the server. A communication protocol such as an HTTP request is used for transmission.

[1022] Error Analysis

[1023] Based on the error content received by the server, the system log and error log are referenced. The server reads the log file from the specified path, extracts and analyzes the relevant entries, and uses text analysis algorithms and regular expressions for the analysis.

[1024] Identifying the cause of the error

[1025] The server uses a generative AI model to analyze and identify the cause of the error. For example, it provides an analysis result such as the possibility that the connection string is incorrect. This generative AI model has learned from past log data and error information, enabling it to identify the cause with high accuracy.

[1026] Solution Generation

[1027] Based on the analysis results, the server uses a generative AI model to generate an appropriate solution, such as a message like "Please check the configuration file and correct the connection string." The generated solution is presented to the user in an easy-to-understand format.

[1028] Providing a solution

[1029] The server sends the generated solution message to the device, usually via an HTTP response, and the device displays the received message to the user, for example, in a pop-up window or notification area.

[1030] Emotion Recognition in Action

[1031] When a user reports an error, the device uses a camera and microphone to capture the user's facial expressions and voice, and inputs this information into the emotion engine. The emotion engine then uses the collected data to recognize the user's emotional state. For example, it can determine that the user is feeling stressed.

[1032] Sentiment-based analysis and customized solutions

[1033] The server receives the emotional information sent from the emotion engine and customizes the analysis results of the generative AI model. Depending on the emotional state, the server generates the optimal solution for the user, such as by refining the details of the solution.

[1034] Specific examples

[1035] If the user reports a "database connection error" and the device detects stress from the user's tone of voice or facial expression, the server will recognize this and generate a detailed guide. The device will display:

[1036] "When you open the configuration file, first check it using a text editor. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that the value is correct."

[1037] In this way, the system of the present invention can quickly and efficiently detect errors and provide solutions, and it can also flexibly respond to the user's emotional state. It can also provide code reviews and personalized advice, improving the overall user experience.

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

[1039] Step 1:

[1040] Receiving error reports

[1041] The user enters details of the system failure or error into the input screen of the terminal. The input includes an error message such as "A database connection error has occurred."

[1042] The terminal sends the entered error content to the server. The HTTP request protocol is used for sending. The output is the data that arrives at the server as an HTTP request.

[1043] Step 2:

[1044] Receiving error details and analyzing logs

[1045] The system log and error log are queried based on the error content received by the server. The error content and the path to the target log file are included as input.

[1046] The server reads the log file, extracts relevant entries, and performs text analysis, specifically extracting error messages and error numbers from the log file. The output is a list of the extracted log entries.

[1047] Step 3:

[1048] Identifying the cause of the error

[1049] The server inputs the extracted log entries into a generative AI model to analyze the cause of the error. As input, a list of log entries is passed to the model.

[1050] The generative AI model uses patterns learned from past data to identify the cause of the error, specifically, "The connection string is likely incorrect." The output is a specific explanation of the cause of the error.

[1051] Step 4:

[1052] Solution Generation

[1053] Based on the analysis results, the server generates an appropriate solution using a generative AI model, with the identified error causes passed as input to the model.

[1054] The generative AI model generates a specific solution based on the cause of the error, for example, a message such as "Please check your configuration file and correct the connection string." The output is a solution message to present to the user.

[1055] Step 5:

[1056] Providing a solution

[1057] The server sends the generated solution message to the terminal, which includes the solution message as input.

[1058] The terminal displays the received message to the user. Specifically, the message is displayed in a pop-up window or notification area. The output is a solution message displayed on the user's screen.

[1059] Step 6:

[1060] Emotion Recognition in Action

[1061] When a user inputs an error report, the device uses a camera and microphone to collect the user's facial expressions and voice. The input includes the user's facial image and voice data.

[1062] The device inputs the collected data into an emotion engine to recognize the user's emotion. For example, it determines that the user is feeling stressed. The output is the recognized emotional state.

[1063] Step 7:

[1064] Sentiment-based analysis and customized solutions

[1065] The server receives the emotion information sent from the emotion engine and customizes the analysis results of the generative AI model. The inputs include the emotional state and the error analysis results.

[1066] Depending on the user's emotional state, the solution is customized by providing more detailed information. For example, a user who is feeling stressed can be provided with a specific, easy-to-understand, step-by-step solution. The output is a solution message customized based on the user's emotions.

[1067] Step 8:

[1068] Providing emotional solutions

[1069] The server sends a solution message that takes into account the emotion information to the terminal, and the customized solution message is included as input.

[1070] The terminal displays this message to the user in a specific and understandable manner, for example, by providing detailed step-by-step instructions. The output is a customized solution message displayed on the user's screen.

[1071] (Application example 2)

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

[1073] In security systems, the possibility of system failures and errors is unavoidable, but responding to them quickly and accurately is difficult. In particular, when a user encounters an error, it is necessary to immediately provide an appropriate solution. Furthermore, a user-friendly response is required, rather than one-sided support that ignores the user's emotional state. Therefore, a system is needed that reduces the stress and frustration users feel when solving errors and improves their satisfaction.

[1074] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving details of a system failure or error from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating an error solution based on the analysis results, means for presenting the generated error solution to the user, and emotion recognition means for recognizing the user's emotional state and customizing a response. This enables automation of error resolution and flexible responses according to the user's emotional state.

[1075] The "means for receiving details of system failures and errors from users" refers to the means for collecting system failures and error messages reported by users through a terminal or interface.

[1076] "Means for analyzing error logs based on received error content" refers to means for analyzing error reports received from users by referencing error log files of systems or software.

[1077] "Method of analyzing the cause of an error using a generative AI model" refers to a method of identifying the root cause of an error based on the analysis results of an error log, using a generative AI model that uses machine learning and deep learning.

[1078] "Means for generating solutions to errors based on analysis results" refers to means for automatically generating specific steps and measures for solving problems based on the results of analysis of the cause of an error by a generative AI model.

[1079] The "means for presenting the generated error solution to the user" refers to a means for notifying and displaying the generated solution to the user in an easy-to-understand manner.

[1080] "Emotion recognition means for recognizing a user's emotional state and customizing a response" refers to a means for analyzing a user's facial expressions and voice to recognize the user's emotional state and provide an appropriate solution or response according to the user's specific emotional state.

[1081] This invention is a system that receives system failures and errors reported by users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it is possible to respond according to the user's emotional state. This specification describes the form of an error analysis and support application for security systems.

[1082] The server first collects error reports from smartphones and other devices as a means of receiving details of system failures and errors from users. The collected error reports are sent to the server. The server then performs error log analysis based on the received error reports. This includes referencing system log files and analyzing the error conditions.

[1083] Next, the server uses a generative AI model to analyze the cause of the error. This generative AI model is based on machine learning and deep learning technologies, and is able to identify the cause with high accuracy by studying a large amount of past data. Once the cause of the error has been identified, the server generates an appropriate solution to the error based on the analysis results. This solution is generated automatically and provided to the user in an easy-to-understand manner.

[1084] The application also incorporates emotion recognition means to recognize the user's emotional state. This emotion recognition utilizes voice recognition software called "emotion_recognition" and machine learning models for emotion recognition. For example, it can determine whether the user is feeling stressed from their tone of voice and facial expression. Based on this information, the server presents customized solutions according to the user's emotional state. This allows for flexible responses tailored to the user's emotions, improving user satisfaction.

[1085] For example, if a user reports that a camera connection error has occurred, the server analyzes the error log and identifies the cause as a camera setting error. If the server recognizes that the user is feeling stressed, it provides a detailed and courteous solution, such as "Open the app's settings screen and check the camera connection settings. Detailed instructions are below..."

[1086] Example prompt sentence:

[1087] "Please receive error reports from users, identify the cause of camera connection errors, and provide detailed step-by-step solutions. Please also take into consideration the frustration expressed by users."

[1088] This system improves user satisfaction by automating error resolution and enabling flexible responses according to the user's emotional state. It also improves the reliability of the security system by providing fast and accurate support.

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

[1090] Step 1:

[1091] The user inputs the details of the system failure or error into their smartphone or device and sends it. For example, the input here is text such as "A camera connection error has occurred." The device then sends this error report to the server.

[1092] Step 2:

[1093] Based on the error report received by the server, the system log and error log are analyzed. The server reads the log file, extracts the log entry related to the reported error, and performs error log analysis. The results of this analysis become the data for the next process.

[1094] Step 3:

[1095] The server uses a generative AI model to identify the cause of the error from the results of error log analysis. The generative AI model is a model that has learned from past error analysis data, and outputs an estimate of the cause of the identified error. Specifically, the output may be a cause such as "mistake in connection settings."

[1096] Step 4:

[1097] The server uses the generative AI model to generate an appropriate solution to the error based on the analysis results. The AI ​​model generates a solution procedure corresponding to the identified cause of the error, such as "Open the app settings screen and check the camera connection settings."

[1098] Step 5:

[1099] When a user reports an error, the device collects the user's voice and facial expression data and uses emotion recognition to recognize the user's emotional state. Specifically, the "emotion_recognition" software analyzes the user's tone of voice and facial expression and outputs an emotional state such as stress or anxiety.

[1100] Step 6:

[1101] The server generates flexible solutions based on the user's emotions based on the emotion recognition results. For example, if the server detects that the user is feeling stressed, it will tailor the solution to provide a detailed step-by-step solution.

[1102] Step 7:

[1103] The server sends the generated solution to the terminal, which displays it to the user. The terminal displays the generated solution message to the user in a user-friendly format, allowing the user to take action.

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

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

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

[1107] [Third embodiment]

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

[1109] 5, the data processing system 310 includes the data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

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

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

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

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

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

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

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

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

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

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

[1120] This invention is a system that automates the process from detecting system errors to analyzing their causes and planning countermeasures. The system utilizes a generative AI model to analyze errors based on user reports and propose appropriate solutions. It also provides code reviews and personalized advice.

[1121] Interactive Debugging Implementation

[1122] 1. Receiving Error Reports

[1123] A user inputs a system failure or error into a terminal. For example, if a user reports that a database connection error has occurred, the terminal sends the information to the server.

[1124] 2. Error Analysis

[1125] The server analyzes system logs and error logs based on the error reports received from users. A generative AI model analyzes the log data and identifies the cause of the error, such as "The connection string may be incorrect."

[1126] 3. Providing a solution

[1127] Based on the cause of the error analyzed by the server, the generative AI model generates an appropriate solution. For example, it generates a message such as "Please check the configuration file and correct the connection string" and presents it to the user via the terminal. The user then follows the suggested solution to check and correct the system settings.

[1128] Code review support implementation example

[1129] 1. Enter and submit the code

[1130] The user enters a code to request a review into the terminal, for example, print("Hello World"), and the terminal sends the code to the server.

[1131] 2. Code Analysis

[1132] The server analyzes the received code using a generative AI model. The model detects code quality and optimization points and generates feedback, such as "Consider changing this code to print(f'Hello World')."

[1133] 3. Providing feedback

[1134] The server generates feedback and sends it to the device, which displays it to the user, who can then modify their code based on the feedback.

[1135] Embodiments of personalized advice

[1136] 1. Request for advice

[1137] A user requests advice on a specific problem, for example, "Please tell me how to fix the last error," by typing the request into the terminal and sending it to the server.

[1138] 2. Check and analyze history

[1139] The server then references the user's past question history and feedback, and generates appropriate advice based on the generative AI model. Based on information extracted from past data, the server provides specific advice such as "Check your configuration file and try a new connection string, just like last time."

[1140] 3. Providing advice

[1141] The server sends the generated advice to the terminal, which displays it to the user, who then configures and operates the system based on the advice.

[1142] Learning and teaching practices

[1143] 1. Enter and submit your question

[1144] The user types a question about a new programming language or framework into the terminal, for example, "What is a generator in Python?", which the terminal then sends to the server.

[1145] 2. Question Analysis and Answer Generation

[1146] The server inputs the received question into a generative AI model for analysis. The model understands the intent of the question and generates an appropriate answer. For example, it generates an answer such as "A generator is a method for easily creating an iterator, and uses the yield keyword."

[1147] 3. Presenting the Answer

[1148] The server generates answers and sends them to the device, which displays them to the user, who can use the information to deepen their understanding of programming languages ​​and frameworks.

[1149] Implementation of security measures

[1150] 1. Entering and Encrypting Registration Information

[1151] A user enters registration information to create a new account into the device, such as a name, email address, and password, which the device then encrypts and sends to the server.

[1152] 2. Secure Data Storage

[1153] The server will then properly decrypt the registration information received and store it securely in a database, decrypting the encrypted data and applying access controls to prevent unauthorized access.

[1154] 3. Confirmation message displayed

[1155] The server sends a confirmation message to the terminal indicating the completion of the account creation, which the terminal displays to the user. The user receives the confirmation message and confirms that the account creation was successfully completed.

[1156] In this way, the system of the present invention automates the process from error detection to cause analysis and countermeasure planning, reducing the workload of system personnel and improving the speed of error recovery.

[1157] The processing flow will be explained below.

[1158] Specific program processing for interactive debugging

[1159] Step 1:

[1160] The user enters the details of the system failure or error into the input screen of the terminal.

[1161] For example: "A database connection error has occurred."

[1162] Step 2:

[1163] The terminal transmits the error content input by the user to the server.

[1164] Step 3:

[1165] Based on the error content received by the server, the system log and error log are referenced.

[1166] Step 4:

[1167] The server reads the log file and parses it for entries related to the error.

[1168] Step 5:

[1169] The server uses the generated AI model to match the log data with the error content and identify the cause of the error.

[1170] For example: "Your connection string may be incorrect."

[1171] Step 6:

[1172] The server generates a solution to the error based on the analysis results.

[1173] For example: "Please check your configuration file and correct your connection string."

[1174] Step 7:

[1175] The server sends the generated solution message to the terminal.

[1176] Step 8:

[1177] The terminal displays the solution message received from the server to the user.

[1178] Step 9:

[1179] The user tries the suggested solutions and checks and corrects system settings.

[1180] Specific program processing for code review support

[1181] Step 1:

[1182] The user pastes the code to request a review into the input screen of the device.

[1183] Example: print("Hello World")

[1184] Step 2:

[1185] The terminal sends the code entered by the user to the server.

[1186] Step 3:

[1187] The server inputs the received code into the generative AI model.

[1188] Step 4:

[1189] The server runs a syntactic analysis of the code through a generative AI model.

[1190] Step 5:

[1191] The server uses generative AI models to generate feedback on code quality and performance.

[1192] For example: "Consider this code to be print(f"Hello World")"

[1193] Step 6:

[1194] The server generates feedback and sends it to the device.

[1195] Step 7:

[1196] The terminal displays the feedback received from the server to the user.

[1197] Step 8:

[1198] The user modifies the code based on the feedback.

[1199] Specific programmatic processing of personalized advice

[1200] Step 1:

[1201] A user requests personalized advice on a particular issue at the device.

[1202] For example: "Please tell me how to resolve the previous error."

[1203] Step 2:

[1204] The terminal sends an advice request to the server.

[1205] Step 3:

[1206] The server references the user's past question history and feedback database to obtain relevant information.

[1207] Example: Previous question "Database connection error"

[1208] Step 4:

[1209] The server uses a generative AI model to generate solutions based on historical data.

[1210] Step 5:

[1211] The server generates specific and appropriate advice.

[1212] For example: "As before, please check your configuration file and try a new connection string."

[1213] Step 6:

[1214] The server sends the generated advice to the terminal.

[1215] Step 7:

[1216] The terminal displays the advice received from the server to the user.

[1217] Step 8:

[1218] The user configures and operates the system based on the advice provided.

[1219] Specific program processing for learning and teaching

[1220] Step 1:

[1221] The user types a question about a new programming language or framework into the terminal.

[1222] For example: "What is a generator in Python?"

[1223] Step 2:

[1224] The device sends the question to the server.

[1225] Step 3:

[1226] The server inputs the received questions into a generative AI model for analysis.

[1227] Step 4:

[1228] The server uses a generative AI model to generate an appropriate answer.

[1229] For example: "Generators are methods that make iterators easier to create, and they use the yield keyword."

[1230] Step 5:

[1231] The server generates a response and sends it to the terminal.

[1232] Step 6:

[1233] The terminal displays the answer received from the server to the user.

[1234] Step 7:

[1235] Users can deepen their understanding of programming languages ​​and frameworks based on the information provided.

[1236] Specific program processing for security measures

[1237] Step 1:

[1238] The user enters registration information into the terminal to create a new account.

[1239] For example: Name, email address, password

[1240] Step 2:

[1241] The terminal encrypts the entered registration information and transmits it to the server.

[1242] Step 3:

[1243] The server properly decrypts the encrypted data to store the received registration information in a database.

[1244] Step 4:

[1245] The server enforces access control and security policies on user data.

[1246] Step 5:

[1247] The server sends a confirmation message to the device indicating that the account creation is complete.

[1248] Step 6:

[1249] The terminal displays to the user the confirmation message received from the server.

[1250] Step 7:

[1251] The user receives the provided confirmation message, confirming successful account creation.

[1252] Example 1

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

[1254] There is a need to automate the process from error detection to cause analysis and response planning, reducing the workload of system personnel while improving error recovery speed. There is also a need to provide code reviews to improve system quality and personalized advice based on users' past question history. Furthermore, from a security standpoint, secure management of user registration information is also essential.

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

[1256] In this invention, the server includes means for receiving failure or error information from a user, means for analyzing logs based on the received error information, means for identifying the cause of the error using a generative AI model, means for generating a solution to the error based on the identified cause, means for presenting the generated solution to the error to the user, means for receiving code from the user and analyzing the code using a generative AI model to generate feedback, means for presenting the generated feedback to the user, means for receiving user questions or requests and generating personalized advice based on past data using a generative AI model, means for presenting the generated advice to the user, means for receiving user registration information, appropriately encrypting it, and transmitting it to the server, and means for appropriately decoding the received information and securely storing it. This enables efficient error detection and rapid recovery, improved code quality, provision of advice tailored to the user, and secure management of registration information.

[1257] A "user" is someone who uses the system to report errors, request code reviews, or request advice.

[1258] "Terminal" means an electronic device used by a user to enter fault or error information, codes, advice requests, registration information, etc.

[1259] A "server" is a computer system that receives information sent from a terminal and uses a generative AI model to analyze and generate solutions.

[1260] "Failure or error information" refers to detailed information or messages regarding system failures or errors.

[1261] A "log" is a collection of data that records the system's operating status, error messages, etc.

[1262] A "generative AI model" is a model that uses artificial intelligence technology to analyze data, generate feedback, and provide advice.

[1263] "Cause of error" refers to the underlying cause of a system failure or error.

[1264] "Solution" refers to specific methods and procedures for restoring the system to the identified cause of the error.

[1265] "Code" refers to the set of instructions and data that make up a program.

[1266] "Feedback" refers to information including evaluations and suggestions regarding code quality and optimization.

[1267] "Question or Request" refers to a question or request for specific information that a user makes to the system.

[1268] "Personalized advice" refers to specialized advice provided based on a user's individual history and context.

[1269] "Registration Information" refers to information such as name, email address, and password that a User enters to create a new Account.

[1270] "Encryption" refers to the process of transforming data to protect it from unauthorized access by third parties.

[1271] "Decoding" refers to the process of returning encrypted data to its original form.

[1272] "Secure storage" refers to storing data in a protected manner, such as in a database, to ensure its confidentiality, integrity, and availability.

[1273] This invention is a system that utilizes a generative AI model to automate the process from detecting system errors to analyzing their causes and planning countermeasures. The system receives error reports from users, analyzes the cause of the error based on the content of the reports, and presents appropriate solutions. It also receives requests for code reviews, analyzes the code, and provides feedback. It also provides personalized advice based on the user's past question history.

[1274] System configuration

[1275] User

[1276] Users use the terminal to enter reports of system outages and errors, as well as to enter requests for code reviews and advice, and to register new accounts.

[1277] Terminal

[1278] The terminal receives input from the user and sends it to the server. Examples of input data include prompts such as "There is a database connection error" or "Please tell me how to resolve the previous error."

[1279] server

[1280] The server receives error information, codes, and requests sent from the device, analyzes them using a generative AI model, and generates appropriate solutions, feedback, and advice, which are then sent to the device and presented to the user.

[1281] Error detection and analysis

[1282] Receiving error reports

[1283] The server receives the error report entered by the user into the terminal. For example, it receives specific error information such as "a database connection error has occurred."

[1284] Log collection and analysis

[1285] The server collects system and error logs based on the error report and analyzes the log data using a generative AI model. As a result of the analysis, it can identify that "the connection string may be incorrect."

[1286] Solution generation and presentation

[1287] Based on the analysis results, the server uses a generative AI model to generate an appropriate solution, such as "Please check your configuration file and correct the connection string."

[1288] Conducting code reviews

[1289] Enter and send the code

[1290] The user enters a code to request a review into the terminal and sends it to the server. For example, enter a code such as print("Hello World").

[1291] Code analysis and feedback

[1292] The server inputs the received code into a generative AI model, analyzes the code's quality and optimization points, and generates feedback such as "Consider changing this code to print(f'Hello World')."

[1293] Providing feedback

[1294] The generated feedback is sent to the terminal and presented to the user, who can then modify the code according to the presented feedback.

[1295] Providing personalized advice

[1296] Receiving a request

[1297] A user requests advice on a specific problem, for example, "Please tell me how to fix the last error."

[1298] Review and analyze historical data

[1299] The server reads the user's past question history and feedback from a database and uses a generative AI model to generate appropriate advice, such as "As before, check your configuration file and try a new connection string."

[1300] Providing advice

[1301] The generated advice is sent to the terminal and presented to the user, allowing the user to solve the problem efficiently.

[1302] Security measures

[1303] Entering and encrypting registration information

[1304] To create a new account, a user enters the necessary registration information (name, email address, password, etc.) into the device, which then encrypts this information and sends it to the server.

[1305] Decryption and storage of registration information

[1306] The server will properly decrypt the received registration information and store it securely in a database. The security of the registration information is guaranteed by using appropriate encryption technology and access control.

[1307] Displaying a confirmation message

[1308] The server generates and sends a confirmation message indicating successful account creation to the terminal, which displays this message to the user to confirm successful account creation.

[1309] In this way, the system of the present invention efficiently detects and quickly recovers from errors, improves code quality, provides tailored advice to users, and securely manages registration information. For example, the system can be used by inputting the following prompts into the generative AI model:

[1310] "I'm getting a database connection error. What's the cause and how can I fix it?"

[1311] "Please review the code print("Hello World")."

[1312] This allows users to receive prompt and appropriate support.

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

[1314] Step 1:

[1315] A user inputs information about a system failure or error into a terminal. For example, "A database connection error has occurred" and sends the input to the server. Input data: Error message. Output data: Error message sent to the server.

[1316] Step 2:

[1317] The server receives error messages sent from the terminal. It records the received error messages in a log file and collects system logs and error logs. Input data: Error messages. Output data: Collected log files.

[1318] Step 3:

[1319] The log data collected by the server is input into the generative AI model to analyze the cause of the error. The generative AI model is used to analyze the log data and identify the cause. For example, a result such as "The connection string may be incorrect" is obtained. Input data: Log data. Output data: Cause of the error.

[1320] Step 4:

[1321] Based on the cause of the error identified by the server, a generative AI model is used to generate an appropriate solution. For example, a message such as "Please check your configuration file and correct the connection string" is generated. Input data: Cause of the error. Output data: Solution message.

[1322] Step 5:

[1323] The server sends the generated solution to the terminal. The terminal receives the message and displays it to the user. The user follows the presented solution to check and correct the system settings. Input data: Solution message. Output data: Display to the user.

[1324] Step 6:

[1325] The user enters the code to be reviewed into the terminal. For example, enter the code print("Hello World"). The code is sent to the server. Input data: Code. Output data: Code sent to the server.

[1326] Step 7:

[1327] The server receives the code sent from the device and inputs it into a generative AI model to analyze the code. The model detects the quality of the code and points for optimization, and generates feedback. For example, it generates feedback such as "Consider changing this code to print(f'Hello World')." Input data: Code. Output data: Feedback.

[1328] Step 8:

[1329] The server generates feedback and sends it to the device. The device receives the feedback and displays it to the user. The user modifies their code based on this feedback. Input data: Feedback. Output data: Display to the user.

[1330] Step 9:

[1331] A user types a request into their terminal for personalized advice on a specific problem. For example, "Please tell me how to fix the last error." The request is sent to the server. Input data: Advice request. Output data: Request sent to the server.

[1332] Step 10:

[1333] The server receives the request and reads the user's past question history and feedback from a database. It uses a generative AI model to generate appropriate personalized advice. For example, it generates advice such as "As before, check your configuration file and try a new connection string." Input data: past question history and requests. Output data: personalized advice.

[1334] Step 11:

[1335] The server generates personalized advice and sends it to the device. The device receives the advice and displays it to the user. The user configures and operates the system according to the advice. Input data: personalized advice. Output data: display to the user.

[1336] Step 12:

[1337] A user enters registration information into a device to create a new account. For example, the user enters a name, email address, password, etc. The device encrypts the entered information and sends it to the server. Input data: Registration information. Output data: Encrypted registration information sent to the server.

[1338] Step 13:

[1339] The server receives the encrypted registration information, properly decrypts it, and stores it securely in a database. Encryption technology and access control are used to ensure the security of the information. Input data: Encrypted registration information. Output data: Information securely stored in a database.

[1340] Step 14:

[1341] The server generates a confirmation message indicating successful account creation and sends it to the terminal. The terminal receives the confirmation message and displays it to the user. The user confirms that account creation was successfully completed. Input data: Confirmation message. Output data: Displayed to the user.

[1342] (Application example 1)

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

[1344] In conventional systems, the detection and analysis of system failures and errors is done manually, which is time-consuming and requires specialized knowledge. Another problem is that it is difficult to quickly provide appropriate solutions when users encounter security-related errors. Furthermore, the mechanisms for providing personalized advice based on past questions and feedback are insufficient, preventing optimal support for individual users. It is necessary to solve these problems, reduce the burden on users, and improve the safety and efficiency of systems.

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

[1346] In this invention, the server includes means for receiving details of system failures and errors from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating a solution to the error based on the analysis results, means for presenting the generated solution to the error to the user, means for automatically notifying of a detected system failure, means for identifying the cause using a generative AI model based on log data, means for generating an appropriate solution based on the cause, and means for presenting the generated solution to the user. This automates the detection and analysis of system failures and errors, enables users to obtain quick and appropriate solutions, and can also provide personalized advice based on past question history, thereby improving the safety and efficiency of the system.

[1347] A "user" is a person or organization that uses the system.

[1348] A "system failure" is an event that disrupts the normal operation of a system and causes errors or malfunctions.

[1349] "Error details" refers to specific information reported by a user about a problem or malfunction related to a system failure.

[1350] An "error log" is information that shows records of errors that occur within the system.

[1351] A "generative AI model" is an artificial intelligence model that learns from large amounts of data and is used for analysis and generation.

[1352] "Analysis" is the process of examining given data or information in detail and making judgments.

[1353] A "Solution" is a specific technique or instruction for correcting or working around a specific problem or error.

[1354] A "means" is a method or device used to achieve a specific function or purpose within a system.

[1355] "Notification" refers to the act or means of informing a user of a specific event or information.

[1356] "Log data" refers to recorded data such as operation history and error information within the system.

[1357] "Cause" refers to the source or reason for a system failure or error.

[1358] A "solution" is a specific procedure or measure to resolve a specific problem or error.

[1359] "Question history" is a record of questions and inquiries that a user has made to the system in the past.

[1360] "Personalized advice" is advice that is tailored to the individual user based on their individual circumstances and history.

[1361] An "activity" is a series of operations or actions that a user performs when using a system.

[1362] To implement this invention, it is necessary to build a system that includes the following elements: The system receives error reports from users, analyzes them using a generative AI model, and proposes solutions. Furthermore, a security assistant app is installed on a smartphone and provides personalized advice based on the user's past question history and feedback.

[1363] System Hardware and Software

[1364] Hardware

[1365] Smartphone: iOS or Android device

[1366] Server: High-performance computer server, database server (e.g. MySQL, PostgreSQL)

[1367] software

[1368] Operating system: iOS or Android on the smartphone, Linux (e.g. Ubuntu) on the server

[1369] Generative AI model: OpenAI API

[1370] Log management software: Python logging module

[1371] Data analysis libraries: Python's standard library and additional libraries (e.g., Pandas, NumPy)

[1372] Detailed system description

[1373] 1. Receiving Error Reports

[1374] When a user reports a system failure or error, the smartphone app receives the details and sends them to the server, where the error message is stored along with the log data.

[1375] 2. Error Analysis

[1376] The server uses a generative AI model to analyze the received error messages and system logs. Specifically, it uses the OpenAI API to analyze the error messages and log data as input and identify the cause of the error.

[1377] 3. Providing a solution

[1378] After identifying the cause of the error, the server again uses the generative AI model to generate an appropriate solution. For example, it might generate specific instructions such as, "Check your firewall settings and block unauthorized access." The generated solution is then sent to the user's smartphone and presented to them.

[1379] 4. Personalized advice

[1380] Based on the user's previous questions and feedback, generative AI models are used to provide personalized advice that is tailored to the user's individual needs.

[1381] Specific examples

[1382] Use case 1: Reporting error messages and suggesting solutions

[1383] What the user does: Report the error message "Unauthorized access attempt detected."

[1384] Prompt sentence to input to the generative AI model:

[1385] Analyze the following error: Unauthorized access attempt detected and log data: {log_data}

[1386] Generated solution:

[1387] Check your device's firewall and ensure it is properly configured to block unauthorized access attempts.

[1388] Use case 2: Personalized advice

[1389] What users do: Ask for advice based on previous security questions.

[1390] Prompt sentence to input to the generative AI model:

[1391] Provide personalized security advice based on the user's past questions: How to secure my WiFi? Tips for safe online banking?

[1392] Generated advice:

[1393] To secure your WiFi, make sure to use a strong password, update your router firmware regularly, and use WPA3 encryption if available. For safe online banking, always use a secure and private internet connection, enable two-factor authentication, and regularly monitor your account for any suspicious activities.

[1394] The present invention allows users to obtain fast and accurate security measures and error resolution through an automated system, improving the safety and efficiency of the system.

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

[1396] Step 1: Receiving an error message

[1397] The terminal receives an error message as input from the user. For example, the user enters the message "Unauthorized access attempt detected." The terminal sends this error message to the server.

[1398] Input: User-supplied error message

[1399] Output: Sends an error message to the server

[1400] Step 2: Logging the error report

[1401] The server records the error message received from the terminal in a log file. Specifically, the error message is added to the error log.

[1402] Input: Error message

[1403] Output: Record the error message in the log data.

[1404] Step 3: Analyze the error message

[1405] The server inputs the log data and error messages into the generative AI model for analysis. The generative AI model (OpenAI API) analyzes the error messages and log data to identify the cause of the error.

[1406] Input: Log data, error message

[1407] Data processing: Generative AI models analyze log data and error messages

[1408] Output: Information about the cause of the error

[1409] Step 4: Generate a solution

[1410] The server inputs the cause of the error identified in step 3 into the generative AI model and generates an appropriate solution, for example, "Check your device's firewall and ensure it is properly configured to block unauthorized access attempts."

[1411] Input: Cause of error

[1412] Data processing: Generative AI models generate solutions

[1413] Output: Solution message

[1414] Step 5: Providing a solution

[1415] The server sends the generated solution to the terminal, and the terminal displays the solution to the user, allowing the user to know the specific countermeasure.

[1416] Input: Solution message

[1417] Output: Send the solution to the terminal and display it to the user

[1418] Step 6: Request personalized advice

[1419] The user requests advice based on past question history and feedback. For example, based on the history, the user enters a message such as "How to secure my WiFi?" into the device, requesting appropriate advice. The device then sends this request to the server.

[1420] Input: Advice request message

[1421] Output: Sends a request message to the server

[1422] Step 7: Review history and generate advice

[1423] The server checks the user's past question history and feedback, and uses a generative AI model to generate personalized advice, such as "To secure your WiFi, make sure to use a strong password..."

[1424] Input: User's past question history, feedback

[1425] Data processing: Generative AI models generate personalized advice

[1426] Output: Advice message

[1427] Step 8: Providing advice

[1428] The server transmits the generated personalized advice to the terminal, and the terminal displays the advice to the user, so that the user can act based on the specific advice.

[1429] Enter: personalized advice

[1430] Output: Sends advice to terminal and displays it to the user

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

[1432] This system receives information about system failures and errors from users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it responds according to the user's emotional state. This system automates the process from error detection to presenting solutions, improving user satisfaction.

[1433] Basic error analysis and solution presentation

[1434] 1. Receiving Error Reports

[1435] The user inputs the details of the system failure or error into the input screen of the terminal. For example, if the user reports that a database connection error has occurred, the terminal sends the details to the server.

[1436] 2. Error Analysis

[1437] Based on the error received by the server, the system log and error log are referenced. The server reads the log files and analyzes the relevant entries.

[1438] 3. Identifying the cause of the error

[1439] The server uses the generative AI model to analyze and identify the cause of the error, for example, "Your connection string may be incorrect."

[1440] 4. Solution Generation

[1441] Based on the analysis results, the server generates an appropriate solution using a generative AI model, such as a message saying, "Please check your configuration file and correct the connection string."

[1442] 5. Providing a solution

[1443] The server generates a solution message and sends it to the terminal, which displays it to the user. The user can follow the solution provided to check and correct the system settings.

[1444] An embodiment of error handling that combines an emotion engine

[1445] 6. Emotion Recognition Implementation

[1446] When a user inputs an error report, the device uses an emotion engine to recognize the user's emotions based on the user's facial expressions and voice. For example, it may determine that the user is feeling stressed.

[1447] 7. Emotion-Based Analysis

[1448] The server receives the recognized emotion information and uses it to further customize the analysis results of the generative AI model. For example, if a user is feeling stressed, it will provide a "specific and easy-to-understand step-by-step solution."

[1449] 8. Providing emotional solutions

[1450] The server generates a solution message based on the emotional information and sends it to the device, which then displays it to the user. For example, the message might say, "We'll start by explaining how to open the configuration file and then provide detailed instructions on how to modify the connection string."

[1451] Examples:

[1452] When a user reports a "database connection error," the device detects stress from the user's tone of voice and facial expression. The server recognizes this and generates a more detailed guide, which looks like this:

[1453] "When you open the configuration file, first check it using a text editor. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that the value is correct."

[1454] Code review support implementation example

[1455] 1. Enter and submit the code

[1456] The user enters a code into the terminal to request a review. Example: print("Hello World")

[1457] 2. Code Analysis

[1458] The device sends the code to the server, which then uses a generative AI model to analyze the code, for example, checking syntax and finding optimization points.

[1459] 3. Utilizing the Emotion Engine

[1460] The emotion engine also works during code reviews to recognize the user's emotional state, for example, shortening the feedback if the user is feeling tired.

[1461] 4. Generating and Presenting Feedback

[1462] The server generates appropriate feedback based on the analysis results and presents it to the user via the terminal. For example, feedback such as "Consider changing this code to print(f'Hello World')" is provided. The wording and content of the feedback are adjusted as necessary, taking into account emotional information.

[1463] Embodiments of personalized advice

[1464] 1. Request for advice

[1465] A user requests advice on a specific problem at the terminal, for example, by typing "Please tell me how to fix the last error."

[1466] 2. History Check and Emotion Recognition

[1467] The device sends an advice request to the server, which then refers to the user's past question history and feedback. At the same time, the emotion engine recognizes the user's emotional state.

[1468] 3. Generating and Presenting Advice

[1469] The server uses a generative AI model to generate appropriate advice based on historical data and the user's emotional state. Taking into account the user's emotional state, the server adjusts the content and presentation of the advice as needed. For example, the advice might be, "As before, check your configuration file and try a new connection string."

[1470] In this way, by combining emotion engines, it is possible to respond flexibly and appropriately according to the user's emotional state. The present invention not only improves error recovery speed but also improves user satisfaction.

[1471] The processing flow will be explained below.

[1472] Specific program processing for error handling that combines an emotion engine

[1473] Step 1:

[1474] The user enters the details of the system failure or error into the input screen of the terminal.

[1475] For example: "A database connection error has occurred."

[1476] Step 2:

[1477] The terminal transmits the error content input by the user to the server.

[1478] Step 3:

[1479] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[1480] Example: "User is feeling stressed"

[1481] Step 4:

[1482] The device transmits emotional state data to the server.

[1483] Step 5:

[1484] Based on the error content and emotion data received by the server, the system log and error log are referenced, and the log files are read and related entries are analyzed.

[1485] Step 6:

[1486] The server uses the generative AI model to analyze and identify the cause of the error.

[1487] For example: "Your connection string may be incorrect."

[1488] Step 7:

[1489] Based on the recognized emotion information, the server generates a solution including detailed guidance if the user is feeling stressed.

[1490] Example: "I'll start by explaining how to open the configuration file and then show you in detail how to modify the connection string."

[1491] Step 8:

[1492] Sends server-generated error resolution messages to the terminal.

[1493] Step 9:

[1494] The terminal displays the solution message received from the server to the user.

[1495] For example: "When you open the configuration file, first use a text editor to look at it. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that its value is correct."

[1496] Step 10:

[1497] The user checks and corrects the system settings according to the suggested solutions.

[1498] Specific program processing of emotion engine in code review support

[1499] Step 1:

[1500] The user pastes the code to request a review into the input screen of the device.

[1501] Example: print("Hello World")

[1502] Step 2:

[1503] The terminal sends the code entered by the user to the server.

[1504] Step 3:

[1505] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[1506] Example: "User is tired"

[1507] Step 4:

[1508] The device transmits emotional state data to the server.

[1509] Step 5:

[1510] The server inputs the received code into a generative AI model and performs syntax analysis of the code.

[1511] Step 6:

[1512] The server uses generative AI models to generate feedback on code quality and performance.

[1513] For example: "Consider this code to be print(f"Hello World")"

[1514] Step 7:

[1515] Based on the emotional information recognized by the server, the system adjusts the feedback, such as by simplifying it for tired users.

[1516] Step 8:

[1517] The server generates feedback and sends it to the device.

[1518] Step 9:

[1519] The terminal displays the feedback received from the server to the user.

[1520] Step 10:

[1521] The user modifies the code based on the feedback.

[1522] Specific program processing of emotion engine for personalized advice

[1523] Step 1:

[1524] A user requests advice on a particular problem at a terminal.

[1525] For example: "Please tell me how to resolve the previous error."

[1526] Step 2:

[1527] The terminal sends an advice request to the server.

[1528] Step 3:

[1529] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[1530] Example: "Users are feeling anxious"

[1531] Step 4:

[1532] The device transmits emotional state data to the server.

[1533] Step 5:

[1534] The server references the user's past question history and feedback database to obtain relevant information.

[1535] Step 6:

[1536] The server uses a generative AI model to generate advice based on past data.

[1537] For example: "As before, please check your configuration file and try a new connection string."

[1538] Step 7:

[1539] Based on the recognized emotional information, the server adjusts its advice to provide more polite and specific advice to users who are feeling anxious.

[1540] Step 8:

[1541] The server sends the generated advice to the terminal.

[1542] Step 9:

[1543] The terminal displays the advice received from the server to the user.

[1544] Step 10:

[1545] The user configures and operates the system based on the advice provided.

[1546] This system enables flexible and appropriate responses that take into account the user's emotional state, thereby improving error recovery speed and user satisfaction.

[1547] Example 2

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

[1549] In conventional systems, even when an error is reported by a user, it takes a long time to identify the cause and present a solution, which results in a decrease in user satisfaction. Furthermore, because the system is unable to respond flexibly and consider the user's emotional state, it is difficult to provide sufficient support, especially to users who are feeling stressed.

[1550] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for receiving details of a system failure or error from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating an error solution based on the analysis results, means for recognizing the emotional state of the user, means for customizing a solution based on the recognized emotional state, and means for presenting the generated error solution to the user. This enables quick processing from error detection to solution presentation and flexible response according to the user's emotional state.

[1551] "User" refers to a person or process that uses the system.

[1552] "Contents of system failures and errors" refers to detailed information about problems or abnormalities that prevent the system from functioning properly.

[1553] "Error log" refers to records and data regarding errors and failures that occur within a system.

[1554] A "generative AI model" is a model that uses machine learning and deep learning to learn patterns and knowledge from data and perform specific tasks.

[1555] "Cause of error" refers to the factors or underlying problems that cause a system failure or error.

[1556] "Error resolution" refers to specific steps or methods for correcting a detected error and restoring the system to a normal state.

[1557] "Emotional state" refers to the current emotional state of the user as determined from their facial expressions, voice, behavior, etc.

[1558] "Customizing the solution" refers to optimizing the error solution depending on the user's emotional state and situation.

[1559] This system receives information about system failures and errors from users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it responds according to the user's emotional state. This system automates the process from error detection to presenting solutions, improving user satisfaction.

[1560] The system of the present invention performs operations by assigning specific roles to the server, terminal, and user.

[1561] Receiving error reports

[1562] The user enters the details of a system failure or error into the input screen of the terminal. For example, a user may report that a database connection error has occurred. The terminal then sends this information to the server. A communication protocol such as an HTTP request is used for transmission.

[1563] Error Analysis

[1564] Based on the error content received by the server, the system log and error log are referenced. The server reads the log file from the specified path, extracts and analyzes the relevant entries, and uses text analysis algorithms and regular expressions for the analysis.

[1565] Identifying the cause of the error

[1566] The server uses a generative AI model to analyze and identify the cause of the error. For example, it provides an analysis result such as the possibility that the connection string is incorrect. This generative AI model has learned from past log data and error information, enabling it to identify the cause with high accuracy.

[1567] Solution Generation

[1568] Based on the analysis results, the server uses a generative AI model to generate an appropriate solution, such as a message like "Please check the configuration file and correct the connection string." The generated solution is presented to the user in an easy-to-understand format.

[1569] Providing a solution

[1570] The server sends the generated solution message to the device, usually via an HTTP response, and the device displays the received message to the user, for example, in a pop-up window or notification area.

[1571] Emotion Recognition in Action

[1572] When a user reports an error, the device uses a camera and microphone to capture the user's facial expressions and voice, and inputs this information into the emotion engine. The emotion engine then uses the collected data to recognize the user's emotional state. For example, it can determine that the user is feeling stressed.

[1573] Sentiment-based analysis and customized solutions

[1574] The server receives the emotional information sent from the emotion engine and customizes the analysis results of the generative AI model. Depending on the emotional state, the server generates the optimal solution for the user, such as by refining the details of the solution.

[1575] Specific examples

[1576] If the user reports a "database connection error" and the device detects stress from the user's tone of voice or facial expression, the server will recognize this and generate a detailed guide. The device will display:

[1577] "When you open the configuration file, first check it using a text editor. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that the value is correct."

[1578] In this way, the system of the present invention can quickly and efficiently detect errors and provide solutions, and it can also flexibly respond to the user's emotional state. It can also provide code reviews and personalized advice, improving the overall user experience.

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

[1580] Step 1:

[1581] Receiving error reports

[1582] The user enters details of the system failure or error into the input screen of the terminal. The input includes an error message such as "A database connection error has occurred."

[1583] The terminal sends the entered error content to the server. The HTTP request protocol is used for sending. The output is the data that arrives at the server as an HTTP request.

[1584] Step 2:

[1585] Receiving error details and analyzing logs

[1586] The system log and error log are queried based on the error content received by the server. The error content and the path to the target log file are included as input.

[1587] The server reads the log file, extracts relevant entries, and performs text analysis, specifically extracting error messages and error numbers from the log file. The output is a list of the extracted log entries.

[1588] Step 3:

[1589] Identifying the cause of the error

[1590] The server inputs the extracted log entries into a generative AI model to analyze the cause of the error. As input, a list of log entries is passed to the model.

[1591] The generative AI model uses patterns learned from past data to identify the cause of the error, specifically, "The connection string is likely incorrect." The output is a specific explanation of the cause of the error.

[1592] Step 4:

[1593] Solution Generation

[1594] Based on the analysis results, the server generates an appropriate solution using a generative AI model, with the identified error causes passed as input to the model.

[1595] The generative AI model generates a specific solution based on the cause of the error, for example, a message such as "Please check your configuration file and correct the connection string." The output is a solution message to present to the user.

[1596] Step 5:

[1597] Providing a solution

[1598] The server sends the generated solution message to the terminal, which includes the solution message as input.

[1599] The terminal displays the received message to the user. Specifically, the message is displayed in a pop-up window or notification area. The output is a solution message displayed on the user's screen.

[1600] Step 6:

[1601] Emotion Recognition in Action

[1602] When a user inputs an error report, the device uses a camera and microphone to collect the user's facial expressions and voice. The input includes the user's facial image and voice data.

[1603] The device inputs the collected data into an emotion engine to recognize the user's emotion. For example, it determines that the user is feeling stressed. The output is the recognized emotional state.

[1604] Step 7:

[1605] Sentiment-based analysis and customized solutions

[1606] The server receives the emotion information sent from the emotion engine and customizes the analysis results of the generative AI model. The inputs include the emotional state and the error analysis results.

[1607] Depending on the user's emotional state, the solution is customized by providing more detailed information. For example, a user who is feeling stressed can be provided with a specific, easy-to-understand, step-by-step solution. The output is a solution message customized based on the user's emotions.

[1608] Step 8:

[1609] Providing emotional solutions

[1610] The server sends a solution message that takes into account the emotion information to the terminal, and the customized solution message is included as input.

[1611] The terminal displays this message to the user in a specific and understandable manner, for example, by providing detailed step-by-step instructions. The output is a customized solution message displayed on the user's screen.

[1612] (Application example 2)

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

[1614] In security systems, the possibility of system failures and errors is unavoidable, but responding to them quickly and accurately is difficult. In particular, when a user encounters an error, it is necessary to immediately provide an appropriate solution. Furthermore, a user-friendly response is required, rather than one-sided support that ignores the user's emotional state. Therefore, a system is needed that reduces the stress and frustration users feel when solving errors and improves their satisfaction.

[1615] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving details of a system failure or error from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating an error solution based on the analysis results, means for presenting the generated error solution to the user, and emotion recognition means for recognizing the user's emotional state and customizing a response. This enables automation of error resolution and flexible responses according to the user's emotional state.

[1616] The "means for receiving details of system failures and errors from users" refers to the means for collecting system failures and error messages reported by users through a terminal or interface.

[1617] "Means for analyzing error logs based on received error content" refers to means for analyzing error reports received from users by referencing error log files of systems or software.

[1618] "Method of analyzing the cause of an error using a generative AI model" refers to a method of identifying the root cause of an error based on the analysis results of an error log, using a generative AI model that uses machine learning and deep learning.

[1619] "Means for generating solutions to errors based on analysis results" refers to means for automatically generating specific steps and measures for solving problems based on the results of analysis of the cause of an error by a generative AI model.

[1620] The "means for presenting the generated error solution to the user" refers to a means for notifying and displaying the generated solution to the user in an easy-to-understand manner.

[1621] "Emotion recognition means for recognizing a user's emotional state and customizing a response" refers to a means for analyzing a user's facial expressions and voice to recognize the user's emotional state and provide an appropriate solution or response according to the user's specific emotional state.

[1622] This invention is a system that receives system failures and errors reported by users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it is possible to respond according to the user's emotional state. This specification describes the form of an error analysis and support application for security systems.

[1623] The server first collects error reports from smartphones and other devices as a means of receiving details of system failures and errors from users. The collected error reports are sent to the server. The server then performs error log analysis based on the received error reports. This includes referencing system log files and analyzing the error conditions.

[1624] Next, the server uses a generative AI model to analyze the cause of the error. This generative AI model is based on machine learning and deep learning technologies, and is able to identify the cause with high accuracy by studying a large amount of past data. Once the cause of the error has been identified, the server generates an appropriate solution to the error based on the analysis results. This solution is generated automatically and provided to the user in an easy-to-understand manner.

[1625] The application also incorporates emotion recognition means to recognize the user's emotional state. This emotion recognition utilizes voice recognition software called "emotion_recognition" and machine learning models for emotion recognition. For example, it can determine whether the user is feeling stressed from their tone of voice and facial expression. Based on this information, the server presents customized solutions according to the user's emotional state. This allows for flexible responses tailored to the user's emotions, improving user satisfaction.

[1626] For example, if a user reports that a camera connection error has occurred, the server analyzes the error log and identifies the cause as a camera setting error. If the server recognizes that the user is feeling stressed, it provides a detailed and courteous solution, such as "Open the app's settings screen and check the camera connection settings. Detailed instructions are below..."

[1627] Example prompt sentence:

[1628] "Please receive error reports from users, identify the cause of camera connection errors, and provide detailed step-by-step solutions. Please also take into consideration the frustration expressed by users."

[1629] This system improves user satisfaction by automating error resolution and enabling flexible responses according to the user's emotional state. It also improves the reliability of the security system by providing fast and accurate support.

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

[1631] Step 1:

[1632] The user inputs the details of the system failure or error into their smartphone or device and sends it. For example, the input here is text such as "A camera connection error has occurred." The device then sends this error report to the server.

[1633] Step 2:

[1634] Based on the error report received by the server, the system log and error log are analyzed. The server reads the log file, extracts the log entry related to the reported error, and performs error log analysis. The results of this analysis become the data for the next process.

[1635] Step 3:

[1636] The server uses a generative AI model to identify the cause of the error from the results of error log analysis. The generative AI model is a model that has learned from past error analysis data, and outputs an estimate of the cause of the identified error. Specifically, the output may be a cause such as "mistake in connection settings."

[1637] Step 4:

[1638] The server uses the generative AI model to generate an appropriate solution to the error based on the analysis results. The AI ​​model generates a solution procedure corresponding to the identified cause of the error, such as "Open the app settings screen and check the camera connection settings."

[1639] Step 5:

[1640] When a user reports an error, the device collects the user's voice and facial expression data and uses emotion recognition to recognize the user's emotional state. Specifically, the "emotion_recognition" software analyzes the user's tone of voice and facial expression and outputs an emotional state such as stress or anxiety.

[1641] Step 6:

[1642] The server generates flexible solutions based on the user's emotions based on the emotion recognition results. For example, if the server detects that the user is feeling stressed, it will tailor the solution to provide a detailed step-by-step solution.

[1643] Step 7:

[1644] The server sends the generated solution to the terminal, which displays it to the user. The terminal displays the generated solution message to the user in a user-friendly format, allowing the user to take action.

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

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

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

[1648] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1662] This invention is a system that automates the process from detecting system errors to analyzing their causes and planning countermeasures. The system utilizes a generative AI model to analyze errors based on user reports and propose appropriate solutions. It also provides code reviews and personalized advice.

[1663] Interactive Debugging Implementation

[1664] 1. Receiving Error Reports

[1665] A user inputs a system failure or error into a terminal. For example, if a user reports that a database connection error has occurred, the terminal sends the information to the server.

[1666] 2. Error Analysis

[1667] The server analyzes system logs and error logs based on the error reports received from users. A generative AI model analyzes the log data and identifies the cause of the error, such as "The connection string may be incorrect."

[1668] 3. Providing a solution

[1669] Based on the cause of the error analyzed by the server, the generative AI model generates an appropriate solution. For example, it generates a message such as "Please check the configuration file and correct the connection string" and presents it to the user via the terminal. The user then follows the suggested solution to check and correct the system settings.

[1670] Code review support implementation example

[1671] 1. Enter and submit the code

[1672] The user enters a code to request a review into the terminal, for example, print("Hello World"), and the terminal sends the code to the server.

[1673] 2. Code Analysis

[1674] The server analyzes the received code using a generative AI model. The model detects code quality and optimization points and generates feedback, such as "Consider changing this code to print(f'Hello World')."

[1675] 3. Providing feedback

[1676] The server generates feedback and sends it to the device, which displays it to the user, who can then modify their code based on the feedback.

[1677] Embodiments of personalized advice

[1678] 1. Request for advice

[1679] A user requests advice on a specific problem, for example, "Please tell me how to fix the last error," by typing the request into the terminal and sending it to the server.

[1680] 2. Check and analyze history

[1681] The server then references the user's past question history and feedback, and generates appropriate advice based on the generative AI model. Based on information extracted from past data, the server provides specific advice such as "Check your configuration file and try a new connection string, just like last time."

[1682] 3. Providing advice

[1683] The server sends the generated advice to the terminal, which displays it to the user, who then configures and operates the system based on the advice.

[1684] Learning and teaching practices

[1685] 1. Enter and submit your question

[1686] The user types a question about a new programming language or framework into the terminal, for example, "What is a generator in Python?", which the terminal then sends to the server.

[1687] 2. Question Analysis and Answer Generation

[1688] The server inputs the received question into a generative AI model for analysis. The model understands the intent of the question and generates an appropriate answer. For example, it generates an answer such as "A generator is a method for easily creating an iterator, and uses the yield keyword."

[1689] 3. Presenting the Answer

[1690] The server generates answers and sends them to the device, which displays them to the user, who can use the information to deepen their understanding of programming languages ​​and frameworks.

[1691] Implementation of security measures

[1692] 1. Entering and Encrypting Registration Information

[1693] A user enters registration information to create a new account into the device, such as a name, email address, and password, which the device then encrypts and sends to the server.

[1694] 2. Secure Data Storage

[1695] The server will then properly decrypt the registration information received and store it securely in a database, decrypting the encrypted data and applying access controls to prevent unauthorized access.

[1696] 3. Confirmation message displayed

[1697] The server sends a confirmation message to the terminal indicating the completion of the account creation, which the terminal displays to the user. The user receives the confirmation message and confirms that the account creation was successfully completed.

[1698] In this way, the system of the present invention automates the process from error detection to cause analysis and countermeasure planning, reducing the workload of system personnel and improving the speed of error recovery.

[1699] The processing flow will be explained below.

[1700] Specific program processing for interactive debugging

[1701] Step 1:

[1702] The user enters the details of the system failure or error into the input screen of the terminal.

[1703] For example: "A database connection error has occurred."

[1704] Step 2:

[1705] The terminal transmits the error content input by the user to the server.

[1706] Step 3:

[1707] Based on the error content received by the server, the system log and error log are referenced.

[1708] Step 4:

[1709] The server reads the log file and parses it for entries related to the error.

[1710] Step 5:

[1711] The server uses the generated AI model to match the log data with the error content and identify the cause of the error.

[1712] For example: "Your connection string may be incorrect."

[1713] Step 6:

[1714] The server generates a solution to the error based on the analysis results.

[1715] For example: "Please check your configuration file and correct your connection string."

[1716] Step 7:

[1717] The server sends the generated solution message to the terminal.

[1718] Step 8:

[1719] The terminal displays the solution message received from the server to the user.

[1720] Step 9:

[1721] The user tries the suggested solutions and checks and corrects system settings.

[1722] Specific program processing for code review support

[1723] Step 1:

[1724] The user pastes the code to request a review into the input screen of the device.

[1725] Example: print("Hello World")

[1726] Step 2:

[1727] The terminal sends the code entered by the user to the server.

[1728] Step 3:

[1729] The server inputs the received code into the generative AI model.

[1730] Step 4:

[1731] The server runs a syntactic analysis of the code through a generative AI model.

[1732] Step 5:

[1733] The server uses generative AI models to generate feedback on code quality and performance.

[1734] For example: "Consider this code to be print(f"Hello World")"

[1735] Step 6:

[1736] The server generates feedback and sends it to the device.

[1737] Step 7:

[1738] The terminal displays the feedback received from the server to the user.

[1739] Step 8:

[1740] The user modifies the code based on the feedback.

[1741] Specific programmatic processing of personalized advice

[1742] Step 1:

[1743] A user requests personalized advice on a particular issue at the device.

[1744] For example: "Please tell me how to resolve the previous error."

[1745] Step 2:

[1746] The terminal sends an advice request to the server.

[1747] Step 3:

[1748] The server references the user's past question history and feedback database to obtain relevant information.

[1749] Example: Previous question "Database connection error"

[1750] Step 4:

[1751] The server uses a generative AI model to generate solutions based on historical data.

[1752] Step 5:

[1753] The server generates specific and appropriate advice.

[1754] For example: "As before, please check your configuration file and try a new connection string."

[1755] Step 6:

[1756] The server sends the generated advice to the terminal.

[1757] Step 7:

[1758] The terminal displays the advice received from the server to the user.

[1759] Step 8:

[1760] The user configures and operates the system based on the advice provided.

[1761] Specific program processing for learning and teaching

[1762] Step 1:

[1763] The user types a question about a new programming language or framework into the terminal.

[1764] For example: "What is a generator in Python?"

[1765] Step 2:

[1766] The device sends the question to the server.

[1767] Step 3:

[1768] The server inputs the received questions into a generative AI model for analysis.

[1769] Step 4:

[1770] The server uses a generative AI model to generate an appropriate answer.

[1771] For example: "Generators are methods that make iterators easier to create, and they use the yield keyword."

[1772] Step 5:

[1773] The server generates a response and sends it to the terminal.

[1774] Step 6:

[1775] The terminal displays the answer received from the server to the user.

[1776] Step 7:

[1777] Users can deepen their understanding of programming languages ​​and frameworks based on the information provided.

[1778] Specific program processing for security measures

[1779] Step 1:

[1780] The user enters registration information into the terminal to create a new account.

[1781] For example: Name, email address, password

[1782] Step 2:

[1783] The terminal encrypts the entered registration information and transmits it to the server.

[1784] Step 3:

[1785] The server properly decrypts the encrypted data to store the received registration information in a database.

[1786] Step 4:

[1787] The server enforces access control and security policies on user data.

[1788] Step 5:

[1789] The server sends a confirmation message to the device indicating that the account creation is complete.

[1790] Step 6:

[1791] The terminal displays to the user the confirmation message received from the server.

[1792] Step 7:

[1793] The user receives the provided confirmation message, confirming successful account creation.

[1794] Example 1

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

[1796] There is a need to automate the process from error detection to cause analysis and response planning, reducing the workload of system personnel while improving error recovery speed. There is also a need to provide code reviews to improve system quality and personalized advice based on users' past question history. Furthermore, from a security standpoint, secure management of user registration information is also essential.

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

[1798] In this invention, the server includes means for receiving failure or error information from a user, means for analyzing logs based on the received error information, means for identifying the cause of the error using a generative AI model, means for generating a solution to the error based on the identified cause, means for presenting the generated solution to the error to the user, means for receiving code from the user and analyzing the code using a generative AI model to generate feedback, means for presenting the generated feedback to the user, means for receiving user questions or requests and generating personalized advice based on past data using a generative AI model, means for presenting the generated advice to the user, means for receiving user registration information, appropriately encrypting it, and transmitting it to the server, and means for appropriately decoding the received information and securely storing it. This enables efficient error detection and rapid recovery, improved code quality, provision of advice tailored to the user, and secure management of registration information.

[1799] A "user" is someone who uses the system to report errors, request code reviews, or request advice.

[1800] "Terminal" means an electronic device used by a user to enter fault or error information, codes, advice requests, registration information, etc.

[1801] A "server" is a computer system that receives information sent from a terminal and uses a generative AI model to analyze and generate solutions.

[1802] "Failure or error information" refers to detailed information or messages regarding system failures or errors.

[1803] A "log" is a collection of data that records the system's operating status, error messages, etc.

[1804] A "generative AI model" is a model that uses artificial intelligence technology to analyze data, generate feedback, and provide advice.

[1805] "Cause of error" refers to the underlying cause of a system failure or error.

[1806] "Solution" refers to specific methods and procedures for restoring the system to the identified cause of the error.

[1807] "Code" refers to the set of instructions and data that make up a program.

[1808] "Feedback" refers to information including evaluations and suggestions regarding code quality and optimization.

[1809] "Question or Request" refers to a question or request for specific information that a user makes to the system.

[1810] "Personalized advice" refers to specialized advice provided based on a user's individual history and context.

[1811] "Registration Information" refers to information such as name, email address, and password that a User enters to create a new Account.

[1812] "Encryption" refers to the process of transforming data to protect it from unauthorized access by third parties.

[1813] "Decoding" refers to the process of returning encrypted data to its original form.

[1814] "Secure storage" refers to storing data in a protected manner, such as in a database, to ensure its confidentiality, integrity, and availability.

[1815] This invention is a system that utilizes a generative AI model to automate the process from detecting system errors to analyzing their causes and planning countermeasures. The system receives error reports from users, analyzes the cause of the error based on the content of the reports, and presents appropriate solutions. It also receives requests for code reviews, analyzes the code, and provides feedback. It also provides personalized advice based on the user's past question history.

[1816] System configuration

[1817] User

[1818] Users use the terminal to enter reports of system outages and errors, as well as to enter requests for code reviews and advice, and to register new accounts.

[1819] Terminal

[1820] The terminal receives input from the user and sends it to the server. Examples of input data include prompts such as "There is a database connection error" or "Please tell me how to resolve the previous error."

[1821] server

[1822] The server receives error information, codes, and requests sent from the device, analyzes them using a generative AI model, and generates appropriate solutions, feedback, and advice, which are then sent to the device and presented to the user.

[1823] Error detection and analysis

[1824] Receiving error reports

[1825] The server receives the error report entered by the user into the terminal. For example, it receives specific error information such as "a database connection error has occurred."

[1826] Log collection and analysis

[1827] The server collects system and error logs based on the error report and analyzes the log data using a generative AI model. As a result of the analysis, it can identify that "the connection string may be incorrect."

[1828] Solution generation and presentation

[1829] Based on the analysis results, the server uses a generative AI model to generate an appropriate solution, such as "Please check your configuration file and correct the connection string."

[1830] Conducting code reviews

[1831] Enter and send the code

[1832] The user enters a code to request a review into the terminal and sends it to the server. For example, enter a code such as print("Hello World").

[1833] Code analysis and feedback

[1834] The server inputs the received code into a generative AI model, analyzes the code's quality and optimization points, and generates feedback such as "Consider changing this code to print(f'Hello World')."

[1835] Providing feedback

[1836] The generated feedback is sent to the terminal and presented to the user, who can then modify the code according to the presented feedback.

[1837] Providing personalized advice

[1838] Receiving a request

[1839] A user requests advice on a specific problem, for example, "Please tell me how to fix the last error."

[1840] Review and analyze historical data

[1841] The server reads the user's past question history and feedback from a database and uses a generative AI model to generate appropriate advice, such as "As before, check your configuration file and try a new connection string."

[1842] Providing advice

[1843] The generated advice is sent to the terminal and presented to the user, allowing the user to solve the problem efficiently.

[1844] Security measures

[1845] Entering and encrypting registration information

[1846] To create a new account, a user enters the necessary registration information (name, email address, password, etc.) into the device, which then encrypts this information and sends it to the server.

[1847] Decryption and storage of registration information

[1848] The server will properly decrypt the received registration information and store it securely in a database. The security of the registration information is guaranteed by using appropriate encryption technology and access control.

[1849] Displaying a confirmation message

[1850] The server generates and sends a confirmation message indicating successful account creation to the terminal, which displays this message to the user to confirm successful account creation.

[1851] In this way, the system of the present invention efficiently detects and quickly recovers from errors, improves code quality, provides tailored advice to users, and securely manages registration information. For example, the system can be used by inputting the following prompts into the generative AI model:

[1852] "I'm getting a database connection error. What's the cause and how can I fix it?"

[1853] "Please review the code print("Hello World")."

[1854] This allows users to receive prompt and appropriate support.

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

[1856] Step 1:

[1857] A user inputs information about a system failure or error into a terminal. For example, "A database connection error has occurred" and sends the input to the server. Input data: Error message. Output data: Error message sent to the server.

[1858] Step 2:

[1859] The server receives error messages sent from the terminal. It records the received error messages in a log file and collects system logs and error logs. Input data: Error messages. Output data: Collected log files.

[1860] Step 3:

[1861] The log data collected by the server is input into the generative AI model to analyze the cause of the error. The generative AI model is used to analyze the log data and identify the cause. For example, a result such as "The connection string may be incorrect" is obtained. Input data: Log data. Output data: Cause of the error.

[1862] Step 4:

[1863] Based on the cause of the error identified by the server, a generative AI model is used to generate an appropriate solution. For example, a message such as "Please check your configuration file and correct the connection string" is generated. Input data: Cause of the error. Output data: Solution message.

[1864] Step 5:

[1865] The server sends the generated solution to the terminal. The terminal receives the message and displays it to the user. The user follows the presented solution to check and correct the system settings. Input data: Solution message. Output data: Display to the user.

[1866] Step 6:

[1867] The user enters the code to be reviewed into the terminal. For example, enter the code print("Hello World"). The code is sent to the server. Input data: Code. Output data: Code sent to the server.

[1868] Step 7:

[1869] The server receives the code sent from the device and inputs it into a generative AI model to analyze the code. The model detects the quality of the code and points for optimization, and generates feedback. For example, it generates feedback such as "Consider changing this code to print(f'Hello World')." Input data: Code. Output data: Feedback.

[1870] Step 8:

[1871] The server generates feedback and sends it to the device. The device receives the feedback and displays it to the user. The user modifies their code based on this feedback. Input data: Feedback. Output data: Display to the user.

[1872] Step 9:

[1873] A user types a request into their terminal for personalized advice on a specific problem. For example, "Please tell me how to fix the last error." The request is sent to the server. Input data: Advice request. Output data: Request sent to the server.

[1874] Step 10:

[1875] The server receives the request and reads the user's past question history and feedback from a database. It uses a generative AI model to generate appropriate personalized advice. For example, it generates advice such as "As before, check your configuration file and try a new connection string." Input data: past question history and requests. Output data: personalized advice.

[1876] Step 11:

[1877] The server generates personalized advice and sends it to the device. The device receives the advice and displays it to the user. The user configures and operates the system according to the advice. Input data: personalized advice. Output data: display to the user.

[1878] Step 12:

[1879] A user enters registration information into a device to create a new account. For example, the user enters a name, email address, password, etc. The device encrypts the entered information and sends it to the server. Input data: Registration information. Output data: Encrypted registration information sent to the server.

[1880] Step 13:

[1881] The server receives the encrypted registration information, properly decrypts it, and stores it securely in a database. Encryption technology and access control are used to ensure the security of the information. Input data: Encrypted registration information. Output data: Information securely stored in a database.

[1882] Step 14:

[1883] The server generates a confirmation message indicating successful account creation and sends it to the terminal. The terminal receives the confirmation message and displays it to the user. The user confirms that account creation was successfully completed. Input data: Confirmation message. Output data: Displayed to the user.

[1884] (Application example 1)

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

[1886] In conventional systems, the detection and analysis of system failures and errors is done manually, which is time-consuming and requires specialized knowledge. Another problem is that it is difficult to quickly provide appropriate solutions when users encounter security-related errors. Furthermore, the mechanisms for providing personalized advice based on past questions and feedback are insufficient, preventing optimal support for individual users. It is necessary to solve these problems, reduce the burden on users, and improve the safety and efficiency of systems.

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

[1888] In this invention, the server includes means for receiving details of system failures and errors from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating a solution to the error based on the analysis results, means for presenting the generated solution to the error to the user, means for automatically notifying of a detected system failure, means for identifying the cause using a generative AI model based on log data, means for generating an appropriate solution based on the cause, and means for presenting the generated solution to the user. This automates the detection and analysis of system failures and errors, enables users to obtain quick and appropriate solutions, and can also provide personalized advice based on past question history, thereby improving the safety and efficiency of the system.

[1889] A "user" is a person or organization that uses the system.

[1890] A "system failure" is an event that disrupts the normal operation of a system and causes errors or malfunctions.

[1891] "Error details" refers to specific information reported by a user about a problem or malfunction related to a system failure.

[1892] An "error log" is information that shows records of errors that occur within the system.

[1893] A "generative AI model" is an artificial intelligence model that learns from large amounts of data and is used for analysis and generation.

[1894] "Analysis" is the process of examining given data or information in detail and making judgments.

[1895] A "Solution" is a specific technique or instruction for correcting or working around a specific problem or error.

[1896] A "means" is a method or device used to achieve a specific function or purpose within a system.

[1897] "Notification" refers to the act or means of informing a user of a specific event or information.

[1898] "Log data" refers to recorded data such as operation history and error information within the system.

[1899] "Cause" refers to the source or reason for a system failure or error.

[1900] A "solution" is a specific procedure or measure to resolve a specific problem or error.

[1901] "Question history" is a record of questions and inquiries that a user has made to the system in the past.

[1902] "Personalized advice" is advice that is tailored to the individual user based on their individual circumstances and history.

[1903] An "activity" is a series of operations or actions that a user performs when using a system.

[1904] To implement this invention, it is necessary to build a system that includes the following elements: The system receives error reports from users, analyzes them using a generative AI model, and proposes solutions. Furthermore, a security assistant app is installed on a smartphone and provides personalized advice based on the user's past question history and feedback.

[1905] System Hardware and Software

[1906] Hardware

[1907] Smartphone: iOS or Android device

[1908] Server: High-performance computer server, database server (e.g. MySQL, PostgreSQL)

[1909] software

[1910] Operating system: iOS or Android on the smartphone, Linux (e.g. Ubuntu) on the server

[1911] Generative AI model: OpenAI API

[1912] Log management software: Python logging module

[1913] Data analysis libraries: Python's standard library and additional libraries (e.g., Pandas, NumPy)

[1914] Detailed system description

[1915] 1. Receiving Error Reports

[1916] When a user reports a system failure or error, the smartphone app receives the details and sends them to the server, where the error message is stored along with the log data.

[1917] 2. Error Analysis

[1918] The server uses a generative AI model to analyze the received error messages and system logs. Specifically, it uses the OpenAI API to analyze the error messages and log data as input and identify the cause of the error.

[1919] 3. Providing a solution

[1920] After identifying the cause of the error, the server again uses the generative AI model to generate an appropriate solution. For example, it might generate specific instructions such as, "Check your firewall settings and block unauthorized access." The generated solution is then sent to the user's smartphone and presented to them.

[1921] 4. Personalized advice

[1922] Based on the user's previous questions and feedback, generative AI models are used to provide personalized advice that is tailored to the user's individual needs.

[1923] Specific examples

[1924] Use case 1: Reporting error messages and suggesting solutions

[1925] What the user does: Report the error message "Unauthorized access attempt detected."

[1926] Prompt sentence to input to the generative AI model:

[1927] Analyze the following error: Unauthorized access attempt detected and log data: {log_data}

[1928] Generated solution:

[1929] Check your device's firewall and ensure it is properly configured to block unauthorized access attempts.

[1930] Use case 2: Personalized advice

[1931] What users do: Ask for advice based on previous security questions.

[1932] Prompt sentence to input to the generative AI model:

[1933] Provide personalized security advice based on the user's past questions: How to secure my WiFi? Tips for safe online banking?

[1934] Generated advice:

[1935] To secure your WiFi, make sure to use a strong password, update your router firmware regularly, and use WPA3 encryption if available. For safe online banking, always use a secure and private internet connection, enable two-factor authentication, and regularly monitor your account for any suspicious activities.

[1936] The present invention allows users to obtain fast and accurate security measures and error resolution through an automated system, improving the safety and efficiency of the system.

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

[1938] Step 1: Receiving an error message

[1939] The terminal receives an error message as input from the user. For example, the user enters the message "Unauthorized access attempt detected." The terminal sends this error message to the server.

[1940] Input: User-supplied error message

[1941] Output: Sends an error message to the server

[1942] Step 2: Logging the error report

[1943] The server records the error message received from the terminal in a log file. Specifically, the error message is added to the error log.

[1944] Input: Error message

[1945] Output: Record the error message in the log data.

[1946] Step 3: Analyze the error message

[1947] The server inputs the log data and error messages into the generative AI model for analysis. The generative AI model (OpenAI API) analyzes the error messages and log data to identify the cause of the error.

[1948] Input: Log data, error message

[1949] Data processing: Generative AI models analyze log data and error messages

[1950] Output: Information about the cause of the error

[1951] Step 4: Generate a solution

[1952] The server inputs the cause of the error identified in step 3 into the generative AI model and generates an appropriate solution, for example, "Check your device's firewall and ensure it is properly configured to block unauthorized access attempts."

[1953] Input: Cause of error

[1954] Data processing: Generative AI models generate solutions

[1955] Output: Solution message

[1956] Step 5: Providing a solution

[1957] The server sends the generated solution to the terminal, and the terminal displays the solution to the user, allowing the user to know the specific countermeasure.

[1958] Input: Solution message

[1959] Output: Send the solution to the terminal and display it to the user

[1960] Step 6: Request personalized advice

[1961] The user requests advice based on past question history and feedback. For example, based on the history, the user enters a message such as "How to secure my WiFi?" into the device, requesting appropriate advice. The device then sends this request to the server.

[1962] Input: Advice request message

[1963] Output: Sends a request message to the server

[1964] Step 7: Review history and generate advice

[1965] The server checks the user's past question history and feedback, and uses a generative AI model to generate personalized advice, such as "To secure your WiFi, make sure to use a strong password..."

[1966] Input: User's past question history, feedback

[1967] Data processing: Generative AI models generate personalized advice

[1968] Output: Advice message

[1969] Step 8: Providing advice

[1970] The server transmits the generated personalized advice to the terminal, and the terminal displays the advice to the user, so that the user can act based on the specific advice.

[1971] Enter: personalized advice

[1972] Output: Sends advice to terminal and displays it to the user

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

[1974] This system receives information about system failures and errors from users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it responds according to the user's emotional state. This system automates the process from error detection to presenting solutions, improving user satisfaction.

[1975] Basic error analysis and solution presentation

[1976] 1. Receiving Error Reports

[1977] The user inputs the details of the system failure or error into the input screen of the terminal. For example, if the user reports that a database connection error has occurred, the terminal sends the details to the server.

[1978] 2. Error Analysis

[1979] Based on the error received by the server, the system log and error log are referenced. The server reads the log files and analyzes the relevant entries.

[1980] 3. Identifying the cause of the error

[1981] The server uses the generative AI model to analyze and identify the cause of the error, for example, "Your connection string may be incorrect."

[1982] 4. Solution Generation

[1983] Based on the analysis results, the server generates an appropriate solution using a generative AI model, such as a message saying, "Please check your configuration file and correct the connection string."

[1984] 5. Providing a solution

[1985] The server generates a solution message and sends it to the terminal, which displays it to the user. The user can follow the solution provided to check and correct the system settings.

[1986] An embodiment of error handling that combines an emotion engine

[1987] 6. Emotion Recognition Implementation

[1988] When a user inputs an error report, the device uses an emotion engine to recognize the user's emotions based on the user's facial expressions and voice. For example, it may determine that the user is feeling stressed.

[1989] 7. Emotion-Based Analysis

[1990] The server receives the recognized emotion information and uses it to further customize the analysis results of the generative AI model. For example, if a user is feeling stressed, it will provide a "specific and easy-to-understand step-by-step solution."

[1991] 8. Providing emotional solutions

[1992] The server generates a solution message based on the emotional information and sends it to the device, which then displays it to the user. For example, the message might say, "We'll start by explaining how to open the configuration file and then provide detailed instructions on how to modify the connection string."

[1993] Examples:

[1994] When a user reports a "database connection error," the device detects stress from the user's tone of voice and facial expression. The server recognizes this and generates a more detailed guide, which looks like this:

[1995] "When you open the configuration file, first check it using a text editor. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that the value is correct."

[1996] Code review support implementation example

[1997] 1. Enter and submit the code

[1998] The user enters a code into the terminal to request a review. Example: print("Hello World")

[1999] 2. Code Analysis

[2000] The device sends the code to the server, which then uses a generative AI model to analyze the code, for example, checking syntax and finding optimization points.

[2001] 3. Utilizing the Emotion Engine

[2002] The emotion engine also works during code reviews to recognize the user's emotional state, for example, shortening the feedback if the user is feeling tired.

[2003] 4. Generating and Presenting Feedback

[2004] The server generates appropriate feedback based on the analysis results and presents it to the user via the terminal. For example, feedback such as "Consider changing this code to print(f'Hello World')" is provided. The wording and content of the feedback are adjusted as necessary, taking into account emotional information.

[2005] Embodiments of personalized advice

[2006] 1. Request for advice

[2007] A user requests advice on a specific problem at the terminal, for example, by typing "Please tell me how to fix the last error."

[2008] 2. History Check and Emotion Recognition

[2009] The device sends an advice request to the server, which then refers to the user's past question history and feedback. At the same time, the emotion engine recognizes the user's emotional state.

[2010] 3. Generating and Presenting Advice

[2011] The server uses a generative AI model to generate appropriate advice based on historical data and the user's emotional state. Taking into account the user's emotional state, the server adjusts the content and presentation of the advice as needed. For example, the advice might be, "As before, check your configuration file and try a new connection string."

[2012] In this way, by combining emotion engines, it is possible to respond flexibly and appropriately according to the user's emotional state. The present invention not only improves error recovery speed but also improves user satisfaction.

[2013] The processing flow will be explained below.

[2014] Specific program processing for error handling that combines an emotion engine

[2015] Step 1:

[2016] The user enters the details of the system failure or error into the input screen of the terminal.

[2017] For example: "A database connection error has occurred."

[2018] Step 2:

[2019] The terminal transmits the error content input by the user to the server.

[2020] Step 3:

[2021] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[2022] Example: "User is feeling stressed"

[2023] Step 4:

[2024] The device transmits emotional state data to the server.

[2025] Step 5:

[2026] Based on the error content and emotion data received by the server, the system log and error log are referenced, and the log files are read and related entries are analyzed.

[2027] Step 6:

[2028] The server uses the generative AI model to analyze and identify the cause of the error.

[2029] For example: "Your connection string may be incorrect."

[2030] Step 7:

[2031] Based on the recognized emotion information, the server generates a solution including detailed guidance if the user is feeling stressed.

[2032] Example: "I'll start by explaining how to open the configuration file and then show you in detail how to modify the connection string."

[2033] Step 8:

[2034] Sends server-generated error resolution messages to the terminal.

[2035] Step 9:

[2036] The terminal displays the solution message received from the server to the user.

[2037] For example: "When you open the configuration file, first use a text editor to look at it. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that its value is correct."

[2038] Step 10:

[2039] The user checks and corrects the system settings according to the suggested solutions.

[2040] Specific program processing of emotion engine in code review support

[2041] Step 1:

[2042] The user pastes the code to request a review into the input screen of the device.

[2043] Example: print("Hello World")

[2044] Step 2:

[2045] The terminal sends the code entered by the user to the server.

[2046] Step 3:

[2047] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[2048] Example: "User is tired"

[2049] Step 4:

[2050] The device transmits emotional state data to the server.

[2051] Step 5:

[2052] The server inputs the received code into a generative AI model and performs syntax analysis of the code.

[2053] Step 6:

[2054] The server uses generative AI models to generate feedback on code quality and performance.

[2055] For example: "Consider this code to be print(f"Hello World")"

[2056] Step 7:

[2057] Based on the emotional information recognized by the server, the system adjusts the feedback, such as by simplifying it for tired users.

[2058] Step 8:

[2059] The server generates feedback and sends it to the device.

[2060] Step 9:

[2061] The terminal displays the feedback received from the server to the user.

[2062] Step 10:

[2063] The user modifies the code based on the feedback.

[2064] Specific program processing of emotion engine for personalized advice

[2065] Step 1:

[2066] A user requests advice on a particular problem at a terminal.

[2067] For example: "Please tell me how to resolve the previous error."

[2068] Step 2:

[2069] The terminal sends an advice request to the server.

[2070] Step 3:

[2071] The device analyzes the user's facial expressions and voice using an emotion engine to recognize their emotional state.

[2072] Example: "Users are feeling anxious"

[2073] Step 4:

[2074] The device transmits emotional state data to the server.

[2075] Step 5:

[2076] The server references the user's past question history and feedback database to obtain relevant information.

[2077] Step 6:

[2078] The server uses a generative AI model to generate advice based on past data.

[2079] For example: "As before, please check your configuration file and try a new connection string."

[2080] Step 7:

[2081] Based on the recognized emotional information, the server adjusts its advice to provide more polite and specific advice to users who are feeling anxious.

[2082] Step 8:

[2083] The server sends the generated advice to the terminal.

[2084] Step 9:

[2085] The terminal displays the advice received from the server to the user.

[2086] Step 10:

[2087] The user configures and operates the system based on the advice provided.

[2088] This system enables flexible and appropriate responses that take into account the user's emotional state, thereby improving error recovery speed and user satisfaction.

[2089] Example 2

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

[2091] In conventional systems, even when an error is reported by a user, it takes a long time to identify the cause and present a solution, which results in a decrease in user satisfaction. Furthermore, because the system is unable to respond flexibly and consider the user's emotional state, it is difficult to provide sufficient support, especially to users who are feeling stressed.

[2092] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for receiving details of a system failure or error from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating an error solution based on the analysis results, means for recognizing the emotional state of the user, means for customizing a solution based on the recognized emotional state, and means for presenting the generated error solution to the user. This enables quick processing from error detection to solution presentation and flexible response according to the user's emotional state.

[2093] "User" refers to a person or process that uses the system.

[2094] "Contents of system failures and errors" refers to detailed information about problems or abnormalities that prevent the system from functioning properly.

[2095] "Error log" refers to records and data regarding errors and failures that occur within a system.

[2096] A "generative AI model" is a model that uses machine learning and deep learning to learn patterns and knowledge from data and perform specific tasks.

[2097] "Cause of error" refers to the factors or underlying problems that cause a system failure or error.

[2098] "Error resolution" refers to specific steps or methods for correcting a detected error and restoring the system to a normal state.

[2099] "Emotional state" refers to the current emotional state of the user as determined from their facial expressions, voice, behavior, etc.

[2100] "Customizing the solution" refers to optimizing the error solution depending on the user's emotional state and situation.

[2101] This system receives information about system failures and errors from users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it responds according to the user's emotional state. This system automates the process from error detection to presenting solutions, improving user satisfaction.

[2102] The system of the present invention performs operations by assigning specific roles to the server, terminal, and user.

[2103] Receiving error reports

[2104] The user enters the details of a system failure or error into the input screen of the terminal. For example, a user may report that a "database connection error has occurred." The terminal then sends this information to the server. A communication protocol such as an HTTP request is used for transmission.

[2105] Error Analysis

[2106] Based on the error content received by the server, the system log and error log are referenced. The server reads the log file from the specified path, extracts and analyzes the relevant entries, and uses text analysis algorithms and regular expressions for the analysis.

[2107] Identifying the cause of the error

[2108] The server uses a generative AI model to analyze and identify the cause of the error. For example, it provides an analysis result such as the possibility that the connection string is incorrect. This generative AI model has learned from past log data and error information, enabling it to identify the cause with high accuracy.

[2109] Solution Generation

[2110] Based on the analysis results, the server uses a generative AI model to generate an appropriate solution, such as a message like "Please check the configuration file and correct the connection string." The generated solution is presented to the user in an easy-to-understand format.

[2111] Providing a solution

[2112] The server sends the generated solution message to the device, usually via an HTTP response, and the device displays the received message to the user, for example, in a pop-up window or notification area.

[2113] Emotion Recognition in Action

[2114] When a user reports an error, the device uses a camera and microphone to capture the user's facial expressions and voice, and inputs this information into the emotion engine. The emotion engine then uses the collected data to recognize the user's emotional state. For example, it can determine that the user is feeling stressed.

[2115] Sentiment-based analysis and customized solutions

[2116] The server receives the emotional information sent from the emotion engine and customizes the analysis results of the generative AI model. Depending on the emotional state, the server generates the optimal solution for the user, such as by refining the details of the solution.

[2117] Specific examples

[2118] If the user reports a "database connection error" and the device detects stress from the user's tone of voice or facial expression, the server will recognize this and generate a detailed guide. The device will display:

[2119] "When you open the configuration file, first check it using a text editor. Next, find the connection string section. Specifically, there is an item called 'DB_CONNECTION_STRING'. Make sure that the value is correct."

[2120] In this way, the system of the present invention can quickly and efficiently detect errors and provide solutions, and it can also flexibly respond to the user's emotional state. It can also provide code reviews and personalized advice, improving the overall user experience.

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

[2122] Step 1:

[2123] Receiving error reports

[2124] The user enters details of the system failure or error into the input screen of the terminal. The input includes an error message such as "A database connection error has occurred."

[2125] The terminal sends the entered error content to the server. The HTTP request protocol is used for sending. The output is the data that arrives at the server as an HTTP request.

[2126] Step 2:

[2127] Receiving error details and analyzing logs

[2128] The system log and error log are queried based on the error content received by the server. The error content and the path to the target log file are included as input.

[2129] The server reads the log file, extracts relevant entries, and performs text analysis, specifically extracting error messages and error numbers from the log file. The output is a list of the extracted log entries.

[2130] Step 3:

[2131] Identifying the cause of the error

[2132] The server inputs the extracted log entries into a generative AI model to analyze the cause of the error. As input, a list of log entries is passed to the model.

[2133] The generative AI model uses patterns learned from past data to identify the cause of the error, specifically, "The connection string is likely incorrect." The output is a specific explanation of the cause of the error.

[2134] Step 4:

[2135] Solution Generation

[2136] Based on the analysis results, the server generates an appropriate solution using a generative AI model, with the identified error causes passed as input to the model.

[2137] The generative AI model generates a specific solution based on the cause of the error, for example, a message such as "Please check your configuration file and correct the connection string." The output is a solution message to present to the user.

[2138] Step 5:

[2139] Providing a solution

[2140] The server sends the generated solution message to the terminal, which includes the solution message as input.

[2141] The terminal displays the received message to the user. Specifically, the message is displayed in a pop-up window or notification area. The output is a solution message displayed on the user's screen.

[2142] Step 6:

[2143] Emotion Recognition in Action

[2144] When a user inputs an error report, the device uses a camera and microphone to collect the user's facial expressions and voice. The input includes the user's facial image and voice data.

[2145] The device inputs the collected data into an emotion engine to recognize the user's emotion. For example, it determines that the user is feeling stressed. The output is the recognized emotional state.

[2146] Step 7:

[2147] Sentiment-based analysis and customized solutions

[2148] The server receives the emotion information sent from the emotion engine and customizes the analysis results of the generative AI model. The inputs include the emotional state and the error analysis results.

[2149] Depending on the user's emotional state, the solution is customized by providing more detailed information. For example, a user who is feeling stressed can be provided with a specific, easy-to-understand, step-by-step solution. The output is a solution message customized based on the user's emotions.

[2150] Step 8:

[2151] Providing emotional solutions

[2152] The server sends a solution message that takes into account the emotion information to the terminal, and the customized solution message is included as input.

[2153] The terminal displays this message to the user in a specific and understandable manner, for example, by providing detailed step-by-step instructions. The output is a customized solution message displayed on the user's screen.

[2154] (Application example 2)

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

[2156] In security systems, the possibility of system failures and errors is unavoidable, but responding to them quickly and accurately is difficult. In particular, when a user encounters an error, it is necessary to immediately provide an appropriate solution. Furthermore, a user-friendly response is required, rather than one-sided support that ignores the user's emotional state. Therefore, a system is needed that reduces the stress and frustration users feel when solving errors and improves their satisfaction.

[2157] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving details of a system failure or error from a user, means for analyzing an error log based on the received error details, means for analyzing the cause of the error using a generative AI model, means for generating an error solution based on the analysis results, means for presenting the generated error solution to the user, and emotion recognition means for recognizing the user's emotional state and customizing a response. This enables automation of error resolution and flexible responses according to the user's emotional state.

[2158] The "means for receiving details of system failures and errors from users" refers to the means for collecting system failures and error messages reported by users through a terminal or interface.

[2159] "Means for analyzing error logs based on received error content" refers to means for analyzing error reports received from users by referencing error log files of systems or software.

[2160] "Method of analyzing the cause of an error using a generative AI model" refers to a method of identifying the root cause of an error based on the analysis results of an error log, using a generative AI model that uses machine learning and deep learning.

[2161] "Means for generating solutions to errors based on analysis results" refers to means for automatically generating specific steps and measures for solving problems based on the results of analysis of the cause of an error by a generative AI model.

[2162] The "means for presenting the generated error solution to the user" refers to a means for notifying and displaying the generated solution to the user in an easy-to-understand manner.

[2163] "Emotion recognition means for recognizing a user's emotional state and customizing a response" refers to a means for analyzing a user's facial expressions and voice to recognize the user's emotional state and provide an appropriate solution or response according to the user's specific emotional state.

[2164] This invention is a system that receives system failures and errors reported by users, identifies the cause using a generative AI model and error log analysis, and presents appropriate solutions. Furthermore, by combining it with an emotion engine, it is possible to respond according to the user's emotional state. This specification describes the form of an error analysis and support application for security systems.

[2165] The server first collects error reports from smartphones and other devices as a means of receiving details of system failures and errors from users. The collected error reports are sent to the server. The server then performs error log analysis based on the received error reports. This includes referencing system log files and analyzing the error conditions.

[2166] Next, the server uses a generative AI model to analyze the cause of the error. This generative AI model is based on machine learning and deep learning technologies, and is able to identify the cause with high accuracy by studying a large amount of past data. Once the cause of the error has been identified, the server generates an appropriate solution to the error based on the analysis results. This solution is generated automatically and provided to the user in an easy-to-understand manner.

[2167] The application also incorporates emotion recognition means to recognize the user's emotional state. This emotion recognition utilizes voice recognition software called "emotion_recognition" and machine learning models for emotion recognition. For example, it can determine whether the user is feeling stressed from their tone of voice and facial expression. Based on this information, the server presents customized solutions according to the user's emotional state. This allows for flexible responses tailored to the user's emotions, improving user satisfaction.

[2168] For example, if a user reports that a camera connection error has occurred, the server analyzes the error log and identifies the cause as a camera setting error. If the server recognizes that the user is feeling stressed, it provides a detailed and courteous solution, such as "Open the app's settings screen and check the camera connection settings. Detailed instructions are below..."

[2169] Example prompt sentence:

[2170] "Please receive error reports from users, identify the cause of camera connection errors, and provide detailed step-by-step solutions. Please also take into consideration the frustration expressed by users."

[2171] This system improves user satisfaction by automating error resolution and enabling flexible responses according to the user's emotional state. It also improves the reliability of the security system by providing fast and accurate support.

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

[2173] Step 1:

[2174] The user inputs the details of the system failure or error into their smartphone or device and sends it. For example, the input here is text such as "A camera connection error has occurred." The device then sends this error report to the server.

[2175] Step 2:

[2176] Based on the error report received by the server, the system log and error log are analyzed. The server reads the log file, extracts the log entry related to the reported error, and performs error log analysis. The results of this analysis become the data for the next process.

[2177] Step 3:

[2178] The server uses a generative AI model to identify the cause of the error from the results of error log analysis. The generative AI model is a model that has learned from past error analysis data, and outputs an estimate of the cause of the identified error. Specifically, the output may be a cause such as "mistake in connection settings."

[2179] Step 4:

[2180] The server uses the generative AI model to generate an appropriate solution to the error based on the analysis results. The AI ​​model generates a solution procedure corresponding to the identified cause of the error, such as "Open the app settings screen and check the camera connection settings."

[2181] Step 5:

[2182] When a user reports an error, the device collects the user's voice and facial expression data and uses emotion recognition to recognize the user's emotional state. Specifically, the "emotion_recognition" software analyzes the user's tone of voice and facial expression and outputs an emotional state such as stress or anxiety.

[2183] Step 6:

[2184] The server generates flexible solutions based on the user's emotions based on the emotion recognition results. For example, if the server detects that the user is feeling stressed, it will tailor the solution to provide a detailed step-by-step solution.

[2185] Step 7:

[2186] The server sends the generated solution to the terminal, which displays it to the user. The terminal displays the generated solution message to the user in a user-friendly format, allowing the user to take action.

[2187] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

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

[2190] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[2191] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[2192] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[2193] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[2194] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[2195] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[2196] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[2197] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[2198] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[2199] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[2200] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[2201] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[2202] The hardware resource for executing a specific process can be any of the following processors: A CPU is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. A dedicated electrical circuit, such as a field-programmable gate array (FPGA), a programmable logic device (PLD), or an application-specific integrated circuit (ASIC), is a processor with a circuit configuration specifically designed to execute a specific process. Each processor has built-in or connected memory, and uses the memory to execute the specific process.

[2203] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[2204] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[2205] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[2206] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[2207] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[2208] The following is further disclosed regarding the above embodiment.

[2209] (Claim 1)

[2210] A means for receiving details of system failures and errors from users;

[2211] A means of analyzing the error log based on the received error content,

[2212] A means of analyzing the cause of errors using a generative AI model; and

[2213] a means for generating an error resolution solution based on the analysis results;

[2214] means for presenting the generated error resolution to a user;

[2215] A system including:

[2216] (Claim 2)

[2217] 10. The system of claim 1, further comprising means f...

Claims

1. A means for receiving details of system failures and errors from users; A means of analyzing the error log based on the received error content, A means of analyzing the cause of errors using a generative AI model; and a means for generating an error resolution solution based on the analysis results; means for presenting the generated error resolution to a user; A system including:

2. 10. The system of claim 1, further comprising means for receiving code for the system and providing feedback for analyzing and optimizing the code using the generative AI model.

3. 10. The system of claim 1, further comprising means for providing personalized advice using a generative AI model based on a user's past question history and feedback.

Images