Interactive system troubleshooting method and device, electronic equipment and storage medium

Abstract

Embodiments of the invention provide an interactive system troubleshooting method and apparatus, an electronic device and a storage medium. The method comprises the steps of obtaining a fault description text for a target fault; based on the fault description text, an interaction text is generated, a response text for the interaction text is obtained, the interaction text is used for indicating at least one target detection action, the target detection action is used for detecting at least one running state of the system, and the response text is used for representing a detection result of the target detection action; according to the response text, a troubleshooting text is generated, and the troubleshooting text is used for describing a troubleshooting scheme for the target fault. Through an information extraction process based on human-computer interaction, more accurate fault features can be obtained, and thus a corresponding fault removal scheme can be obtained more efficiently and accurately.

Description

Technical Field

[0001] This disclosure relates to the field of artificial intelligence technology, and in particular to an interactive system troubleshooting method, apparatus, electronic device, and storage medium. Background Technology

[0002] During the operation of large-scale online systems, various system failures will inevitably occur. Existing technologies, for example, involve setting up a dedicated fault diagnosis system to monitor and troubleshoot these system failures in order to ensure the operational stability of the online system.

[0003] However, in practical applications, due to the large scale and complexity of online systems, the various problems they generate are also very complex. Existing troubleshooting solutions based on preset troubleshooting rules suffer from low troubleshooting efficiency and poor accuracy. Summary of the Invention

[0004] This disclosure provides an interactive system troubleshooting method, apparatus, electronic device, and storage medium to overcome the problems of low troubleshooting efficiency and poor accuracy.

[0005] In a first aspect, embodiments of this disclosure provide an interactive system troubleshooting method, including:

[0006] Obtain a fault description text for the target fault; process the fault description text using a language model to generate interactive text, and obtain a response text for the interactive text, wherein the interactive text is used to indicate at least one target detection action, the target detection action is used to detect at least one operating state of the system, and the response text is used to characterize the detection result of the target detection action; generate troubleshooting text based on the response text, the troubleshooting text is used to describe a troubleshooting solution for the target fault.

[0007] Secondly, embodiments of this disclosure provide an interactive system troubleshooting device, comprising:

[0008] The acquisition module is used to acquire the fault description text for the target fault;

[0009] The processing module is used to process the fault description text through a language model, generate interactive text, and obtain response text for the interactive text, wherein the interactive text is used to indicate at least one target detection action, the target detection action is used to detect at least one operating state of the system, and the response text is used to characterize the detection result of the target detection action.

[0010] The generation module is used to generate troubleshooting text based on the response text, wherein the troubleshooting text describes a troubleshooting solution for the target fault.

[0011] Thirdly, embodiments of this disclosure provide an electronic device, including: a processor and a memory;

[0012] The memory stores computer-executed instructions;

[0013] The processor executes computer execution instructions stored in the memory, causing the at least one processor to perform the interactive system troubleshooting method described in the first aspect and various possible designs of the first aspect.

[0014] Fourthly, embodiments of this disclosure provide a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the interactive system troubleshooting method described in the first aspect and various possible designs of the first aspect.

[0015] Fifthly, embodiments of this disclosure provide a computer program product, including a computer program that, when executed by a processor, implements the interactive system troubleshooting method described in the first aspect and various possible designs of the first aspect.

[0016] The interactive system troubleshooting method, apparatus, electronic device, and storage medium provided in this embodiment obtain a fault description text for a target fault; process the fault description text using a language model to generate interactive text, and obtain response text for the interactive text. The interactive text indicates at least one target detection action, which detects at least one operating state of the system; the response text characterizes the detection result of the target detection action; and troubleshooting text is generated based on the response text, describing a troubleshooting solution for the target fault. By parsing the fault description text to generate interactive text characterizing the target detection action, the user is guided to input response text characterizing the detection result corresponding to the target detection action. Then, based on the detection result corresponding to the target detection action, a troubleshooting solution is determined. Through the information extraction process based on human-computer interaction, more accurate fault characteristics can be obtained, leading to a more efficient and accurate troubleshooting solution, thus improving troubleshooting efficiency and accuracy. Attached Figure Description

[0017] To more clearly illustrate the technical solutions in the embodiments of this disclosure or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this disclosure. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0018] Figure 1An application scenario diagram of the interactive system troubleshooting method provided in this disclosure embodiment;

[0019] Figure 2 Flowchart of the interactive system troubleshooting method provided in the embodiments of this disclosure Figure 1 ;

[0020] Figure 3 This is a schematic diagram of a human-computer interaction process provided in an embodiment of the present disclosure;

[0021] Figure 4 for Figure 3 A flowchart illustrating the specific implementation of step S103 in the illustrated embodiment;

[0022] Figure 5 A flowchart illustrating the troubleshooting process of the interactive system provided in this embodiment of the disclosure. Figure 2 ;

[0023] Figure 6 for Figure 5 A flowchart illustrating the specific implementation of step S203 in the illustrated embodiment;

[0024] Figure 7 A schematic diagram illustrating the jump process of an information extraction node provided in an embodiment of this disclosure;

[0025] Figure 8 for Figure 6 A flowchart illustrating the specific implementation of step S2033 in the illustrated embodiment;

[0026] Figure 9 This is a schematic diagram of a system troubleshooting process provided in an embodiment of the present disclosure;

[0027] Figure 10 A structural block diagram of the interactive system troubleshooting device provided in the embodiments of this disclosure;

[0028] Figure 11 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present disclosure;

[0029] Figure 12 This is a schematic diagram of the hardware structure of an electronic device provided in an embodiment of this disclosure. Detailed Implementation

[0030] To make the objectives, technical solutions, and advantages of the embodiments of this disclosure clearer, the technical solutions of the embodiments of this disclosure will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this disclosure, and not all embodiments. Based on the embodiments of this disclosure, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this disclosure.

[0031] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this disclosure are all information and data authorized by the user or fully authorized by all parties. Furthermore, the collection, use and processing of the relevant data must comply with the relevant laws, regulations and standards of the relevant countries and regions, and corresponding operation portals are provided for users to choose to authorize or refuse.

[0032] The application scenarios of the embodiments of this disclosure are explained below:

[0033] The interactive system troubleshooting method provided in this disclosure can be applied to application scenarios involving fault diagnosis of online systems. The executing entity in this embodiment can be a server providing fault diagnosis services (hereinafter referred to as the server), a terminal device with fault diagnosis functions, or other electronic devices that perform similar functions. These devices implement the fault diagnosis function by executing the interactive system troubleshooting method provided in this embodiment. Taking a terminal device as an example, the terminal device can implement the above-mentioned fault diagnosis function by running a program locally, by accessing a server, or by combining end-to-end and cloud approaches (implementing some functions locally and others on the server). The implementation methods of servers or other electronic devices are similar and will not be elaborated further.

[0034] In some embodiments, the terminal device or server can implement the interactive system troubleshooting method provided in this application by running various computer-executable instructions or computer programs. For example, computer-executable instructions can be program-level commands, machine instructions, or software instructions. Computer programs can be native programs or software modules in an operating system; they can be local applications, i.e., programs that need to be installed in the operating system to run, or small programs embedded in any APP, i.e., programs that run based on a browser environment. In summary, the aforementioned computer-executable instructions can be any form of instruction, and the aforementioned computer programs can be any form of application, module, or plugin, and the specific implementation can be configured as needed. Further, in some embodiments, the server can be an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud storage, cloud communication, cloud databases, cloud computing, cloud functions, network services, middleware services, domain name services, security services, content delivery networks (CDN), and big data and artificial intelligence platforms. Among these, cloud services can be interactive processing services that can be called by the terminal device.

[0035] Figure 1 This is an application scenario diagram of the interactive system troubleshooting method provided in the embodiments of this disclosure, with reference to... Figure 1 As shown in the illustration, taking a server as the execution subject of the method provided in this embodiment as an example, the server runs a fault diagnosis system. In one possible implementation, the server can also connect to a business system server to obtain the system operation information required for fault diagnosis. After receiving a fault detection request sent by a terminal device, the server determines the fault troubleshooting solution based on the fault description text in the fault detection request, such as the fault number and fault description text, by querying a fault database, and returns it to the terminal device. This allows the system maintenance user on the terminal device side to perform fault repair and maintenance on the online system based on the fault troubleshooting solution provided by the fault diagnosis system.

[0036] In existing technologies, for online system fault diagnosis applications, on the one hand, due to the specific nature of these scenarios, the troubleshooting solutions generated by the fault diagnosis platform must possess sufficient accuracy, realism, and operability. Therefore, unlike ordinary knowledge query and content generation functions that can directly utilize a Large Language Model (LLM) to process user queries and generate answers, directly using an LLM to generate troubleshooting solutions in real-world online system fault diagnosis scenarios can lead to serious consequences due to the "illusion" problem inherent in LLM models. On the other hand, the large scale and complexity of online systems result in highly complex problems, making it difficult to obtain accurate troubleshooting solutions by directly searching fault databases based on fault symptoms.

[0037] This disclosure provides an interactive system troubleshooting method to solve the above-mentioned problems.

[0038] refer to Figure 2 , Figure 2 Flowchart of the interactive system troubleshooting method provided in the embodiments of this disclosure Figure 1 The method of this embodiment can be applied to servers, terminal devices, or electronic devices with similar functions. This interactive system troubleshooting method includes:

[0039] Step S101: Obtain the fault description text for the target fault.

[0040] Step S102: Based on the fault description text, generate interactive text and obtain response text for the interactive text, wherein the interactive text is used to indicate at least one target detection action, the target detection action is used to detect at least one operating state of the system, and the response text is used to characterize the detection result of the target detection action.

[0041] refer to Figure 1 The illustrated application scenario diagram illustrates the method provided in this disclosure by using a server as the execution entity as an example. For instance, the server runs a fault diagnosis platform or provides fault diagnosis services. The terminal device communicating with the server runs a client corresponding to the fault diagnosis platform. The terminal device sends a fault description text for the target fault to the server through this client, and the server obtains the fault description text. Specifically, for example, the fault description text might read "MetaServer service has crashed." This description text is a natural language-based statement input by a user on the terminal device side, such as a system administrator, describing the target fault, namely "MetaServer service failure." Furthermore, the description of this target fault can have various possible implementations depending on the user's language habits. For example, the fault description text could also read "MetaServer service has stopped running," "MetaServer is abnormal," etc. Therefore, any set of text that serves as a fault description can be considered the fault description text referred to in the steps of this embodiment, and there are no limitations on its use here.

[0042] Next, the server processes the fault description text to generate interactive text that guides the user to input more detailed information. For example, after semantic understanding of the fault description text using a large language model, the corresponding fault type is obtained. Then, the database is queried based on the fault type to obtain the interactive text. The interactive text can then be displayed on the terminal device to guide the user to input information. Finally, the response text input by the user from the terminal device is obtained to achieve the purpose of information collection. Specifically, the interactive text indicates a target detection action, and the response text input by the user, based on the guidance content represented by the interactive text, contains the detection result of that target detection action. For example, the interactive text might read: "Please execute the 'test_xxx' command and provide feedback on the command execution result." The target detection action indicated by this interactive text is "execute the 'test_xxx' command and provide feedback on the command execution result." Accordingly, based on the aforementioned guidance in the interactive text, the user on the terminal device will manually perform the target detection action, that is, enter the command 'test_xxx' in a specific function interface. After the command is executed, based on the execution result displayed in the function interface, i.e., the detection result, the user will enter response text, which will be sent by the terminal device to the server. The content of the response text may be, for example, "Normal", "NO", "Detection passed", etc. The above examples of response text content can all be "Detection Result". The content represented by the response text usually matches the target detection action indicated by the interactive text. Then, the server further infers the troubleshooting solution based on the content of the response text. It is understandable that since the action of entering the response text in the above process is performed by the user, there will inevitably be issues such as mismatched content or non-compliance with text format specifications in the "response text". After receiving response text with such problems, the server can process it by detecting, calibrating, or returning prompt information according to preset rules. This situation will not be described in detail here. The names "MetaServer" and "test_xxx" are only examples and do not correspond to specific service or function names.

[0043] Furthermore, after obtaining the response text, the server performs an information extraction. Based on the result of this extraction (i.e., the content of the response text), it executes subsequent troubleshooting reasoning. The steps of generating interactive text and obtaining corresponding response text can be performed multiple times, i.e., multiple rounds of generating interactive text and obtaining corresponding response text. For example, after the first generation of interactive text and its display on the terminal device, the first response text input by the user includes the detection result Info_1. Then, based on a preset inference chain, a second generation of interactive text is performed and displayed on the terminal device, obtaining the second response text input by the user, which includes the detection result Info_2. This process continues, based on the preset inference chain, further obtaining, for example, detection results Info_3, Info_4, etc., thereby achieving multi-dimensional information extraction to improve the accuracy of subsequent troubleshooting reasoning.

[0044] Step S103: Generate troubleshooting text based on the response text. The troubleshooting text is used to describe the troubleshooting solution for the target fault.

[0045] For example, after the service receives the response text, it performs reasoning and fault database detection by parsing the information in the response text, and combines it with a language model to generate troubleshooting text that represents the troubleshooting solution. The troubleshooting text is then displayed on the terminal device to guide the user in subsequent fault recovery and repair. Figure 3 This is a schematic diagram of a human-computer interaction process provided by an embodiment of the present disclosure, which is described below in conjunction with... Figure 3 The above process will be described in detail. For example, the server and the terminal device exchange information in a dialog-like manner, and the interactive content is displayed in a dialog window on the client within the terminal device. Figure 3As shown, after the user enters the fault description text "MetaServer is down" into the client's dialog window, the server, based on this fault description text, uses the semantic recognition and text generation capabilities of the language model to generate interactive text A1 and displays it in the dialog interface. During this process, the language model can further call external functional units as needed to obtain the required information. For example, the content of interactive text A1 might be "Please execute the 'test_xxx' command and provide a feedback result of 'YES'?". Afterwards, the user enters the response text B1 into the client's dialog window, which contains "Yes". Then, the server retrieves the response text B1 from the dialog window, further reasoning with the language model to generate troubleshooting text. For example, as shown in the figure, the troubleshooting text might be: "You can troubleshoot using the following methods: 1. Restart the network device; 2. Check the database service log files to see if there are any errors or anomalies; 3. Test the connectivity of the server where MetaServer is located using the 'pingxxx' command." etc.

[0046] Furthermore, in one possible implementation, such as Figure 4 As shown, the specific implementation of step S103 includes:

[0047] Step S1031: Based on the private domain language model, perform semantic recognition on the response text to obtain the fault handling data corresponding to the target fault. The fault handling data represents the preset troubleshooting process for the target fault.

[0048] Step S1032: Based on the fault handling data, obtain the reference information corresponding to each fault-handling node in the preset fault-handling process.

[0049] Step S1033: Generate troubleshooting text based on the reference information corresponding to each troubleshooting node.

[0050] For example, firstly, a private domain language model refers to a large language model trained on data within a specific feature domain. Due to its richer private domain knowledge, a private domain language model exhibits better performance in a particular domain compared to a general-purpose language model. In this embodiment, the private domain language model is the language model trained on sample data from a fault diagnosis scenario. Further, after the server receives the response text, it performs semantic recognition on the response text based on the private domain language model to obtain the corresponding fault features. The fault features represent meanings such as a parameter value P1 being too high, or the MetaServer server's network connection being disconnected. Subsequently, based on the fault characteristics, a fault database is searched to obtain or generate corresponding fault handling data. The fault handling data represents a preset troubleshooting process for the target fault, that is, a standard operating procedure (SOP) for known types of faults. For example, the preset troubleshooting process consists of multiple troubleshooting nodes, each corresponding to a data processing or judgment step. Then, based on the preset troubleshooting process represented by the fault handling data, each troubleshooting node is executed sequentially to obtain the output corresponding to each troubleshooting node, i.e., reference information. Finally, based on one or more reference information obtained from executing each troubleshooting node, the fault database is further queried, or the reference information is processed through a language model to organize the language and generate troubleshooting text.

[0051] Regarding the fault features generated based on the private domain language model, in one possible implementation, the fault features can be represented by feature identifiers, strings, etc. In another possible implementation, the fault features are represented by intermediate variables in the process of processing the response text using the private domain language model, such as feature arrays, feature matrices, etc. The content of the response text can be understood as key information used to determine the known fault features. Then, based on these fault features, in this embodiment, after semantic recognition of the response text directly using the private domain language model, fault processing data is directly generated using the capabilities of the language model. This eliminates the need for intermediate steps to determine specific fault types, thus avoiding the need to store corresponding troubleshooting solutions based on specific fault types in the fault database. This prevents the problem of fault type mismatch leading to the inability to find a suitable troubleshooting solution, improving the accuracy and success rate of troubleshooting text generation.

[0052] Furthermore, the fault handling data includes the component identifier of the node component corresponding to each fault-handling node, and the node component is used to implement the processing function corresponding to the fault-handling node; in one possible implementation, the specific implementation of step S1032 includes: based on the preset fault-handling process represented by the fault handling data, sequentially calling the node component corresponding to each fault-handling node to obtain the system reference information corresponding to the fault-handling node, wherein the reference information includes at least one of the following: system operating status information, user feedback information, and system external information.

[0053] Specifically, the fault handling data generated based on the private domain language model includes component identifiers for the node components corresponding to each troubleshooting node. These node components are used to implement the processing functions corresponding to each troubleshooting node, such as components for calling external information, components for interpreting private domain knowledge, and components for interacting with the user. In other words, the fault handling data generated by the private domain language model specifically indicates the functional components that need to be called to implement each troubleshooting node. By executing these functional components, reference information corresponding to each troubleshooting node can be obtained, thereby realizing the preset troubleshooting process. In this embodiment, by fully utilizing the capabilities of the private domain language model, the generated fault handling data includes component identifiers for the node components corresponding to each troubleshooting node, thereby achieving accurate and efficient arrangement of the actual reasoning chain of the fault troubleshooting solution, and improving the generation efficiency, accuracy, and effectiveness of the troubleshooting text.

[0054] In this embodiment, a fault description text for a target fault is obtained; based on the fault description text, interactive text is generated, and a response text for the interactive text is obtained. The interactive text indicates at least one target detection action, and the response text represents the detection result of the target detection action. Based on the response text, troubleshooting text is generated, describing a troubleshooting solution for the target fault. By parsing the fault description text to generate interactive text representing the target detection action, the user is guided to input the response text representing the detection result corresponding to the target detection action. Then, based on the detection result corresponding to the target detection action, a troubleshooting solution is determined. Through this human-computer interaction-based information extraction process, more accurate fault characteristics can be obtained, leading to a more efficient and accurate troubleshooting solution, thus improving troubleshooting efficiency and accuracy.

[0055] Furthermore, in Figure 2 In the solution provided by the embodiment shown, since the content of the response text is generated based on the guiding content of the interactive text (the indicated target detection action), the accuracy and rationality of the interactive text generated by the server will directly affect the accuracy and effectiveness of the response text as the information extraction result. Figure 5 A flowchart illustrating the troubleshooting process of the interactive system provided in this embodiment of the disclosure. Figure 2 This embodiment is in Figure 2 Based on the illustrated embodiment, the process of generating interactive text is further refined, and handling steps for atypical faults are added, as shown in the reference. Figure 5 The troubleshooting method for this interactive system includes:

[0056] Step S201: Obtain the fault description text for the target fault.

[0057] Step S202: Obtain the information extraction node corresponding to the fault description text. The information extraction node includes the first node information, which is used to characterize the generation rules of the interactive text.

[0058] Step S203: Generate interactive text corresponding to the fault description text through the information extraction node, and obtain the response text for the interactive text.

[0059] For example, this embodiment provides a method for processing fault description text to generate corresponding interactive text. Specifically, a language model can be used to perform semantic recognition on the fault description text to obtain corresponding fault features. Then, based on the fault features, the text is mapped to the corresponding information extraction node. Each information extraction node corresponds to a functional node or step that guides the user to input specified information by generating interactive text, thereby achieving the purpose of information extraction. Within the information extraction node determined based on the fault features, there are generation rules for the interactive text corresponding to the fault features. For example, when the fault description text text_1 is processed, the corresponding information extraction node Nod_1 contains generation rule A, while when the fault description text text_2 is processed, the corresponding information extraction node Nod_2 contains generation rule B. Here, the fault description text text_1 and the fault description text text_2 indicate different target tracking. That is, for different target faults, the server will map to the corresponding matching information extraction node to generate the corresponding interactive text.

[0060] In one possible implementation, the first node information of the information extraction node includes key text information and corresponding descriptive information. The key text information represents the detection keywords corresponding to the target detection action; the descriptive information represents the rules for constructing the corresponding interactive text based on the detection keywords. For example, in the first node information of the information extraction node, the key text information might be "is_test_xxx_YES," which includes the two detection keywords "test_xxx" and "YES," corresponding to the two execution steps and result verification steps of the target detection action, respectively. "is" can serve as a functional symbol, indicating the question format of the interactive text; for example, "is" represents a general question. The descriptive information might be: "Execution: 'test_xxx' instruction, Execution result: 'YES', Format: General question." Therefore, the rules for constructing the interactive text based on the aforementioned "test_xxx" and "YES" ultimately generate the interactive text based on the first node information as: "Please execute the 'test_xxx' instruction and provide a feedback result of 'YES'?".

[0061] Furthermore, in one possible implementation, the server and terminal device obtain response text through multiple rounds of interaction. Specifically, there are at least two information extraction nodes, the interaction text includes multiple interaction sub-texts obtained based on different information extraction nodes, and the response text includes response sub-texts corresponding to the interaction sub-texts. In this case, for example, the information extraction node also includes second node information, which is used to characterize the processing rules for jumping to the next information extraction node based on the interaction sub-text. For example, as shown... Figure 6 As shown, the specific implementation steps of step S203 include:

[0062] Step S2031: Extract the first node information within the current node based on the current information, and generate the corresponding interactive sub-text.

[0063] Step S2032: Receive the response subtext corresponding to the interactive subtext through the current information extraction node.

[0064] Step S2033: Based on the second node information and response subtext within the current information extraction node, determine the jump information extraction node of the current information extraction node.

[0065] Step S2034: Update the current information extraction node to the jump information extraction node, and return to execute step S2031.

[0066] For example, the server has multiple information extraction nodes implemented by a program. The information extraction nodes can perform data processing and logical judgment based on the information of the second node, thereby realizing the jump between information extraction nodes based on the content of the response sub-information, and thus realizing multiple information extraction steps. Figure 7 This is a schematic diagram illustrating the jump process of an information extraction node provided in an embodiment of the present disclosure, such as... Figure 7 As shown, for example, after generating the corresponding interactive sub-text text_1 through the information extraction node Nod_1, the response sub-text text_2 input by the user in response to the interactive sub-text text_1 is obtained through the information extraction node Nod_1. Based on the content of the response sub-text text_2, the system jumps to the information extraction node Nod_1 for further information extraction. The specific implementation method is similar to that of the information extraction node Nod_1. For example, the system generates the interactive sub-text text_3, receives the response sub-text text_4, and then jumps to the next information extraction node Nod_3, and so on, until the stopping condition is met.

[0067] Among them, the current information extraction node and the jump information extraction node are relative information extraction nodes, for example... Figure 7 In the example shown, when information extraction node Nod_1 is the current information extraction node, the subsequent information extraction node Nod_2 is the redirected information extraction node; and when information extraction node Nod_2 is the current information extraction node, the subsequent information extraction node Nod_3 is the redirected information extraction node, and so on.

[0068] Furthermore, such as Figure 8 As shown, the specific implementation of step S2033 includes:

[0069] Step S2033A: Based on the information from the second node, obtain the field value of the target field within the response subtext. The target field represents the target detection action.

[0070] Step S2033B: Determine the jump information extraction node based on the field value of the target field.

[0071] For example, the second-stage information represents the processing rules for jumping to the next information extraction node based on the interactive subtext. After obtaining the response subtext input by the user in this round of dialogue at the current information extraction node, the field value of the target field within the response subtext is obtained according to the second-stage information. Here, the target field represents the target detection action, and correspondingly, the field value of the target field corresponds to the detection result of the target detection action. The second-stage information is used to achieve the purpose of parsing the response subtext and obtaining the detection result. Then, based on the field value of the target field, that is, the detection result of the target detection action, the next information extraction node for further information extraction is determined, i.e., the jump information extraction node.

[0072] In one possible implementation, the second node information includes at least one target field and at least two corresponding enumeration values, as well as a jump information extraction node corresponding to each enumeration value. The target field in the second stage information corresponds to the target field in the response subtext, and the multiple enumeration values ​​corresponding to a target field are classified and mapped according to the detection results under different target fields, thereby jumping to the corresponding information extraction node.

[0073] Furthermore, regarding the stopping condition in the steps of the above embodiments, one possible implementation is to use the number of loops as the stopping condition, that is, when the number of sent interactive sub-texts (or received response sub-texts) reaches a preset number, the stopping condition is triggered, and then the response sub-text corresponding to each loop round is used as the final response text. In another possible implementation, the stopping condition is triggered by the content of the specific received response sub-text. Specifically, optionally, after step S2032, the following may also be included:

[0074] Step S2032A: Save the response subtext.

[0075] Step S2032B: Obtain the detection results of the target detection action represented by the response subtext generated in at least two loop rounds, and trigger the stop condition based on at least two detection results.

[0076] For example, firstly, the response subtext in this loop is saved. Then, based on the response subtext obtained in this loop and the response subtext obtained in previous loops (i.e., at least two response subtexts), the corresponding detection result is obtained. The specific implementation of obtaining the corresponding detection result by parsing the response subtext has been described in previous embodiments and will not be repeated here. Next, a stop condition is triggered based on at least two detection results (i.e., the execution result of the target operation action represented by the detection result). Specifically, for example, when the server obtains the execution result of target operation action act_1 and the execution result of target operation action act_3, it determines that the fault and solution can be determined based on the above two execution results (i.e., two detection results), and then the above loop interaction and information extraction steps end. In this embodiment, by triggering the stop condition based on the detection results of specific multiple target detection actions, the exit mechanism in the process of extracting information through multi-round interaction is further improved. By accurately determining the exit timing of the multi-round interaction process, the amount of information obtained can be increased while improving interaction efficiency and reducing invalid interaction rounds.

[0077] It should also be noted that steps S2032A and S2032B can be executed independently, that is, the response subtext of the current round of activity can be saved without triggering the stop condition. For example, after saving a preset number of response subtexts, it can be determined whether to trigger the stop condition; or, the stop condition can be triggered but the response subtexts can be not saved. That is, the stop condition can be determined solely based on the response subtexts obtained in the current round, thereby further improving the flexibility of the exit mechanism in multi-round interaction. The specific implementation method can be set as needed.

[0078] Step S204: Generate troubleshooting text based on the detection results corresponding to each response subtext.

[0079] For example, after obtaining the corresponding detection results, since these results are obtained based on specific information extraction logic and guided by interactive text, the corresponding fault characteristics can be determined based on the multiple detection results. Then, by combining the fault database and using a general language model to generate text, the corresponding troubleshooting text can be obtained. The specific implementation process is as follows: Figure 2 The embodiments shown have already been described and will not be repeated here. Furthermore, compared to solutions using a single response text or a single detection result, this embodiment generates troubleshooting text through multiple detection results, which can further improve the accuracy and effectiveness of the troubleshooting text.

[0080] Furthermore, in the above steps of this embodiment, after processing the response text input by the user, troubleshooting solutions are retrieved from the fault database based on the existing standard processing flow, and finally the corresponding troubleshooting text is obtained. That is, through the fault description text, it can be mapped to the corresponding information extraction node, and then the specified information is extracted based on the information extraction node to complete the reasoning of the fault troubleshooting solution (steps S202-S204). However, in a possible case, after processing the fault description text or response text, it is very likely that the existing troubleshooting solutions in the standard processing flow or fault database will not be found. That is, the target fault may be an unknown fault not included in the fault database. In this case, the troubleshooting text can be generated by generating fault phenomenon description data to query the fault database.

[0081] Specifically, in one possible implementation, after step S201, the following is also included:

[0082] Step S205: Obtain the corresponding fault phenomenon data based on the fault description text or response text. The fault phenomenon data is used to describe the system operation phenomenon corresponding to the target fault.

[0083] Step S206: Query the fault database based on the fault phenomenon data to obtain the troubleshooting steps text. The fault database contains system operation phenomena of preset types and corresponding troubleshooting steps.

[0084] Step S207: Arrange the troubleshooting step text based on the language model to generate troubleshooting text.

[0085] First, steps S205 to S207 are troubleshooting solutions for situations where the fault type and cause cannot be determined. These steps can be executed if step S204 fails (i.e., the troubleshooting text cannot be generated based on the detection results corresponding to each response sub-text), or if step S202 fails (i.e., the information extraction node corresponding to the fault description text cannot be obtained). These steps can be configured as needed. In this embodiment, for example, based on the response text composed of multiple response sub-texts obtained in previous steps, if the corresponding troubleshooting text cannot be generated, fault phenomenon data is obtained. This fault phenomenon data describes the system operation phenomena corresponding to the target fault, such as system operation logs, operation indicators, or user-inputted maintenance information. Then, based on the aforementioned analysis operators and information characterizing the system operation phenomena, the fault database is queried, i.e., fault cases and troubleshooting solutions with similar or identical system operation phenomena are retrieved. The fault database stores system operation phenomena and corresponding troubleshooting steps. Next, for each system operation phenomenon, the corresponding troubleshooting steps are retrieved from the fault database, and the troubleshooting steps are text-arranged using a language model to generate the troubleshooting text.

[0086] In this embodiment, for open-type faults, when existing standard processing procedures cannot be followed or corresponding troubleshooting solutions cannot be obtained directly from the fault database, fault phenomenon data is acquired, and text representing the corresponding troubleshooting steps is obtained from the fault database based on the fault phenomenon data. This is equivalent to retrieving the fault database from the fault phenomenon dimension when a complete troubleshooting solution cannot be obtained from the fault database from the fault parameter (detection result) dimension, obtaining multiple troubleshooting steps, and then using a language model to understand and arrange the troubleshooting steps to generate troubleshooting text, ensuring the accuracy and effectiveness of the fault troubleshooting solution and avoiding the illusion problem of language models.

[0087] Further, optionally, after generating the troubleshooting text, the following is also included:

[0088] Step S208: Store the fault description text, troubleshooting text, and corresponding dialogue data in the fault database. The dialogue data includes interactive text and corresponding response text.

[0089] For example, after the above processing steps, fault description text, troubleshooting text, and corresponding dialogue data are generated. The dialogue data includes interactive text and corresponding response text, including interactive sub-text and response sub-text generated in multiple interaction rounds in this embodiment. The fault description text, troubleshooting text, and dialogue data are stored in the fault database as a fault phenomenon description for the target fault, thereby expanding the fault phenomenon data in the fault database.

[0090] The steps of the above solution will be described below with a more specific embodiment. Figure 9 This is a schematic diagram of a system troubleshooting process provided in an embodiment of the present disclosure, such as... Figure 9As shown, on the terminal device side, the fault description text input by the user is received in the client's dialog window and sent to the server. The server then uses a large language model to recognize the fault description text, generates interactive text, and displays it in the client's dialog window. Based on the guiding role of the interactive text, the terminal device receives text input by the user again, i.e., response text. This process can be repeated multiple times, i.e., multiple rounds of interaction within the dialog window, sequentially displaying interactive text and response text (i.e., alternating display of multiple interactive sub-texts and response sub-texts). Afterwards, the server processes the interactive text and response text using the large language model to identify the fault and determine the corresponding processing workflow from the fault database, such as Workflow_1, Workflow_2, and Workflow_3 shown in the diagram. The determined processing workflow, such as Workflow_3, is then used to generate troubleshooting text. On the other hand, if the target processing workflow cannot be determined from the fault database, it is identified as an open fault (i.e., an unknown fault). Based on the fault phenomenon data of the open fault, combined with knowledge base data recording system operation phenomena and system analysis operators, it is processed to finally generate troubleshooting text. Meanwhile, for open faults, relevant data from the processing can be saved as corresponding fault data and stored in the fault database.

[0091] In this embodiment, the implementation of step S201 is the same as that in this disclosure. Figure 2 The implementation of step S101 in the illustrated embodiment is the same, and will not be described in detail here.

[0092] Corresponding to the interactive system troubleshooting in the above embodiments, Figure 10 This is a structural block diagram of an interactive system troubleshooting device provided in an embodiment of this disclosure. The method described in the above embodiments can be executed by this interactive system troubleshooting device, which can be implemented by software and / or hardware, and can be integrated into an electronic device with certain data processing capabilities. The electronic device may include, but is not limited to, mobile terminals with big data processing capabilities, as well as fixed terminals with big data processing capabilities such as desktop computers and supercomputers.

[0093] For ease of explanation, only the parts relevant to embodiments of this disclosure are shown. (Refer to...) Figure 10 The interactive system troubleshooting device 3 includes:

[0094] The acquisition module 31 is used to acquire the fault description text for the target fault;

[0095] The processing module 32 is used to generate interactive text based on the fault description text and obtain response text for the interactive text, wherein the interactive text is used to indicate at least one target detection action and the response text is used to characterize the detection result of the target detection action.

[0096] The generation module 33 is used to generate troubleshooting text based on the response text. The troubleshooting text describes the troubleshooting solution for the target fault.

[0097] According to one or more embodiments of this disclosure, the processing module 32 is specifically configured to: obtain an information extraction node corresponding to the fault description text, wherein the information extraction node includes first node information, the first node information being used to characterize the generation rules of the interactive text; generate interactive text corresponding to the fault description text through the information extraction node, and obtain response text for the interactive text.

[0098] According to one or more embodiments of this disclosure, the first node information of the information extraction node includes key text information and corresponding descriptive information, wherein the key text information is used to characterize the detection keywords corresponding to the target detection action; and the descriptive information is used to characterize the rules for constructing the corresponding interactive text by combining the detection keywords.

[0099] According to one or more embodiments of this disclosure, there are at least two information extraction nodes, the interactive text includes multiple interactive sub-texts obtained based on different information extraction nodes, the response text includes response sub-texts corresponding to the interactive sub-texts, and the information extraction node also includes second node information, which is used to characterize the processing rules for jumping to the next information extraction node based on the interactive sub-texts.

[0100] According to one or more embodiments of this disclosure, when the processing module 32 generates interactive text corresponding to the fault description text through the information extraction node and obtains response text for the interactive text, it is specifically used to: repeatedly execute the following steps until a stop condition is triggered: generate corresponding interactive sub-text based on the first node information within the current information extraction node; receive the response sub-text corresponding to the interactive sub-text through the current information extraction node; determine the jump information extraction node of the current information extraction node based on the second node information within the current information extraction node and the response sub-text; update the current information extraction node to the jump information extraction node, and return to execute the step of generating corresponding interactive sub-text based on the first node information within the current information extraction node.

[0101] According to one or more embodiments of this disclosure, when the processing module 32 determines the jump information extraction node of the current information extraction node based on the second node information and the response subtext within the current information extraction node, it is specifically used to: obtain the field value of the target field in the response subtext based on the second node information, wherein the target field represents the target detection action; and determine the jump information extraction node based on the field value of the target field.

[0102] According to one or more embodiments of this disclosure, after receiving the response subtext corresponding to the interactive subtext through the current information extraction node, the processing module 32 is further configured to: save the response subtext; and / or, obtain the detection results of the target detection action represented by the response subtext generated in at least two loop rounds, and trigger a stop condition based on at least two detection results; the generation module 33 is specifically configured to: generate obstacle removal text based on the detection results corresponding to each response subtext.

[0103] According to one or more embodiments of this disclosure, the second node information includes at least one target field and at least two corresponding enumeration values, as well as jump information extraction nodes corresponding to each enumeration value.

[0104] According to one or more embodiments of this disclosure, the generation module 33 is specifically used for: performing semantic recognition on the response text based on a private domain language model to obtain fault handling data corresponding to the target fault, wherein the fault handling data represents a preset troubleshooting process for the target fault; obtaining reference information corresponding to each troubleshooting node in the preset troubleshooting process based on the fault handling data; and generating troubleshooting text based on the reference information corresponding to each troubleshooting node.

[0105] According to one or more embodiments of this disclosure, the fault handling data includes component identifiers of node components corresponding to each troubleshooting node, and the node components are used to implement the processing functions corresponding to the troubleshooting nodes; when the generation module 33 obtains reference information corresponding to each troubleshooting node in the preset troubleshooting process based on the fault handling data, it is specifically used to: based on the preset troubleshooting process represented by the fault handling data, sequentially call the node components corresponding to each troubleshooting node to obtain system reference information corresponding to the troubleshooting node; wherein, the reference information includes at least one of the following: system operating status information, user feedback information, and system external information.

[0106] According to one or more embodiments of this disclosure, when generating troubleshooting text based on response text, the generation module 33 is specifically configured to: obtain fault phenomenon data based on response text, wherein the fault phenomenon data is used to describe the system operation phenomenon corresponding to the target fault; query the fault database based on the fault phenomenon data to obtain troubleshooting step text, wherein the fault database contains system operation phenomena of preset types and corresponding troubleshooting steps; and arrange the troubleshooting step text based on a language model to generate troubleshooting text.

[0107] According to one or more embodiments of this disclosure, after generating the troubleshooting text, the generation module 33 is further configured to: store the fault description text, the troubleshooting text and the corresponding dialogue data in the fault database, wherein the dialogue data includes interactive text and corresponding response text.

[0108] The acquisition module 31, processing module 32, and generation module 33 are connected sequentially. The interactive system troubleshooting device 3 provided in this embodiment can execute the technical solution of the above method embodiment, and its implementation principle and technical effect are similar, so it will not be described again here.

[0109] Figure 11 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present disclosure, such as... Figure 11 As shown, the electronic device 4 includes:

[0110] Processor 41, and memory 42 communicatively connected to processor 41;

[0111] Memory 42 stores instructions executed by the computer;

[0112] The processor 41 executes computer execution instructions stored in the memory 42 to achieve, for example, Figures 2-9 The interactive system troubleshooting method shown in the embodiment.

[0113] Optionally, the processor 41 and the memory 42 are connected via a bus 43.

[0114] For relevant instructions, please refer to the corresponding text. Figures 2-9 The relevant descriptions and effects of the steps in the corresponding embodiments are understood, and will not be elaborated on here.

[0115] This disclosure provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement this disclosure. Figures 2-9 The interactive system troubleshooting method provided in any of the corresponding embodiments.

[0116] This disclosure provides a computer program product, including a computer program, which, when executed by a processor, implements this disclosure. Figures 2-9 The interactive system troubleshooting method provided in any of the corresponding embodiments.

[0117] To implement the above embodiments, this disclosure also provides an electronic device.

[0118] refer to Figure 12The diagram illustrates a structural schematic of an electronic device 900 suitable for implementing embodiments of the present disclosure. The electronic device 900 can be a terminal device or a server. The terminal device can include, but is not limited to, mobile terminals such as mobile phones, laptops, digital radio receivers, personal digital assistants (PDAs), portable Android devices (PADs), portable media players (PMPs), and in-vehicle terminals (e.g., in-vehicle navigation terminals), as well as fixed terminals such as digital TVs and desktop computers. Figure 12 The electronic device shown is merely an example and should not be construed as limiting the functionality and scope of the embodiments disclosed herein.

[0119] like Figure 12 As shown, the electronic device 900 may include a processing unit (e.g., a central processing unit, a graphics processing unit, etc.) 901, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 902 or a program loaded from a storage device 908 into a random access memory (RAM) 903. The RAM 903 also stores various programs and data required for the operation of the electronic device 900. The processing unit 901, ROM 902, and RAM 903 are interconnected via a bus 904. An input / output (I / O) interface 905 is also connected to the bus 904.

[0120] Typically, the following devices can be connected to I / O interface 905: input devices 906 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 907 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 908 including, for example, magnetic tapes, hard disks, etc.; and communication devices 909. Communication device 909 allows electronic device 900 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 12 An electronic device 900 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively.

[0121] In particular, according to embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this disclosure include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device 909, or installed from a storage device 908, or installed from a ROM 902. When the computer program is executed by a processing device 901, it performs the functions defined in the methods of embodiments of this disclosure.

[0122] It should be noted that the computer-readable medium described in this disclosure can be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this disclosure, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in connection with an instruction execution system, apparatus, or device. In this disclosure, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium can be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.

[0123] The aforementioned computer-readable medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device.

[0124] The aforementioned computer-readable medium carries one or more programs, which, when executed by the electronic device, cause the electronic device to perform the methods shown in the above embodiments.

[0125] Computer program code for performing the operations of this disclosure can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0126] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0127] The units or modules described in the embodiments of this disclosure can be implemented in software or hardware. The names of the units or modules do not necessarily limit the specific unit itself.

[0128] The functions described above in this document can be performed, at least in part, by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: Field Programmable Gate Arrays (FPGAs), Application-Specific Integrated Circuits (ASICs), Application Standard Products (ASSPs), System-on-Chip (SoCs), Complex Programmable Logic Devices (CPLDs), and so on.

[0129] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0130] In a first aspect, according to one or more embodiments of this disclosure, an interactive system troubleshooting method is provided, comprising:

[0131] Obtain a fault description text for the target fault; process the fault description text using a language model to generate interactive text, and obtain a response text for the interactive text, wherein the interactive text is used to indicate at least one target detection action, and the response text is used to characterize the detection result of the target detection action; generate troubleshooting text based on the response text, wherein the troubleshooting text is used to describe a troubleshooting solution for the target fault.

[0132] According to one or more embodiments of this disclosure, the step of processing the fault description text through a language model to generate interactive text and obtaining response text for the interactive text includes: obtaining an information extraction node corresponding to the fault description text, wherein the information extraction node includes first node information, the first node information being used to characterize the generation rules of the interactive text; generating the interactive text corresponding to the fault description text through the information extraction node, and obtaining response text for the interactive text.

[0133] According to one or more embodiments of this disclosure, the first node information of the information extraction node includes key text information and corresponding descriptive information, wherein the key text information is used to characterize the detection keywords corresponding to the target detection action; and the descriptive information is used to characterize the rules for constructing the corresponding interactive text by combining the detection keywords.

[0134] According to one or more embodiments of this disclosure, there are at least two information extraction nodes, the interactive text includes multiple interactive sub-texts obtained based on different information extraction nodes, the response text includes a response sub-text corresponding to the interactive sub-text, and the information extraction node also includes second node information, which is used to characterize the processing rules for jumping to the next information extraction node based on the interactive sub-text.

[0135] According to one or more embodiments of this disclosure, the step of generating interactive text corresponding to the fault description text through the information extraction node and obtaining response text for the interactive text includes: repeatedly executing the following steps until a stop condition is triggered: generating corresponding interactive sub-text based on the first node information within the current information extraction node; receiving the response sub-text corresponding to the interactive sub-text through the current information extraction node; determining the jump information extraction node of the current information extraction node based on the second node information within the current information extraction node and the response sub-text; updating the current information extraction node to the jump information extraction node, and returning to execute the step of generating corresponding interactive sub-text based on the first node information within the current information extraction node.

[0136] According to one or more embodiments of this disclosure, determining the jump information extraction node of the current information extraction node based on the second node information within the current information extraction node and the response subtext includes: obtaining the field value of a target field within the response subtext based on the second node information, wherein the target field represents the target detection action; and determining the jump information extraction node based on the field value of the target field.

[0137] According to one or more embodiments of this disclosure, after receiving the response subtext corresponding to the interactive subtext through the current information extraction node, the method further includes: saving the response subtext; and / or obtaining the detection results of the target detection action represented by the response subtext generated in at least two loop rounds, and triggering the stop condition based on at least two of the detection results; the step of generating troubleshooting text based on the response text includes: generating the troubleshooting text based on the detection results corresponding to each of the response subtexts.

[0138] According to one or more embodiments of this disclosure, the second node information includes at least one target field and at least two corresponding enumeration values, as well as jump information extraction nodes corresponding to each of the enumeration values.

[0139] According to one or more embodiments of this disclosure, generating troubleshooting text based on the response text includes: performing semantic recognition on the response text based on a private domain language model to obtain fault handling data corresponding to the target fault, wherein the fault handling data represents a preset troubleshooting process for the target fault; obtaining reference information corresponding to each troubleshooting node in the preset troubleshooting process based on the fault handling data; and generating troubleshooting text based on the reference information corresponding to each troubleshooting node.

[0140] According to one or more embodiments of this disclosure, the fault handling data includes component identifiers of node components corresponding to each troubleshooting node, and the node components are used to implement the processing functions corresponding to the troubleshooting node; obtaining reference information corresponding to each troubleshooting node in the preset troubleshooting process based on the fault handling data includes: based on the preset troubleshooting process represented by the fault handling data, sequentially calling the node components corresponding to each troubleshooting node to obtain system reference information corresponding to the troubleshooting node; wherein, the reference information includes at least one of the following: system operating status information, user feedback information, and system external information.

[0141] According to one or more embodiments of this disclosure, generating troubleshooting text based on the response text includes: obtaining fault phenomenon data based on the response text, the fault phenomenon data being used to describe the system operation phenomenon corresponding to the target fault; querying a fault database based on the fault phenomenon data to obtain troubleshooting step text, wherein the fault database contains system operation phenomena of preset types and corresponding troubleshooting steps; and arranging the troubleshooting step text based on a language model to generate the troubleshooting text.

[0142] According to one or more embodiments of this disclosure, after generating the troubleshooting text, the method further includes: storing the fault description text, the troubleshooting text, and the corresponding dialogue data in the fault database, wherein the dialogue data includes interactive text and corresponding response text.

[0143] Secondly, according to one or more embodiments of this disclosure, an interactive system troubleshooting is provided, including:

[0144] The acquisition module is used to acquire the fault description text for the target fault;

[0145] The processing module is used to process the fault description text through a language model, generate interactive text, and obtain response text for the interactive text, wherein the interactive text is used to indicate at least one target detection action, and the response text is used to characterize the detection result of the target detection action;

[0146] The generation module is used to generate troubleshooting text based on the response text, wherein the troubleshooting text describes a troubleshooting solution for the target fault.

[0147] According to one or more embodiments of this disclosure, the processing module is specifically configured to: obtain an information extraction node corresponding to the fault description text, wherein the information extraction node includes first node information, the first node information being used to characterize the generation rules of the interactive text; generate interactive text corresponding to the fault description text through the information extraction node, and obtain response text for the interactive text.

[0148] According to one or more embodiments of this disclosure, the first node information of the information extraction node includes key text information and corresponding descriptive information, wherein the key text information is used to characterize the detection keywords corresponding to the target detection action; and the descriptive information is used to characterize the rules for constructing the corresponding interactive text by combining the detection keywords.

[0149] According to one or more embodiments of this disclosure, there are at least two information extraction nodes, the interactive text includes multiple interactive sub-texts obtained based on different information extraction nodes, the response text includes a response sub-text corresponding to the interactive sub-text, and the information extraction node also includes second node information, which is used to characterize the processing rules for jumping to the next information extraction node based on the interactive sub-text.

[0150] According to one or more embodiments of this disclosure, when the processing module generates interactive text corresponding to the fault description text through the information extraction node and obtains response text for the interactive text, it is specifically configured to: repeatedly execute the following steps until a stop condition is triggered: generate corresponding interactive sub-text based on the first node information within the current information extraction node; receive the response sub-text corresponding to the interactive sub-text through the current information extraction node; determine the jump information extraction node of the current information extraction node based on the second node information within the current information extraction node and the response sub-text; update the current information extraction node to the jump information extraction node, and return to execute the step of generating corresponding interactive sub-text based on the first node information within the current information extraction node.

[0151] According to one or more embodiments of this disclosure, when the processing module determines the jump information extraction node of the current information extraction node based on the second node information within the current information extraction node and the response subtext, it is specifically configured to: obtain the field value of the target field within the response subtext based on the second node information, wherein the target field represents the target detection action; and determine the jump information extraction node based on the field value of the target field.

[0152] According to one or more embodiments of this disclosure, after receiving the response subtext corresponding to the interactive subtext through the current information extraction node, the processing module is further configured to: save the response subtext; and / or, obtain the detection results of the target detection action represented by the response subtext generated in at least two loop rounds, and trigger the stopping condition based on at least two of the detection results; the generation module is specifically configured to: generate the obstacle removal text based on the detection results corresponding to each of the response subtexts.

[0153] According to one or more embodiments of this disclosure, the second node information includes at least one target field and at least two corresponding enumeration values, as well as jump information extraction nodes corresponding to each of the enumeration values.

[0154] According to one or more embodiments of this disclosure, the generation module is specifically used for: performing semantic recognition on the response text based on a private domain language model to obtain fault handling data corresponding to the target fault, wherein the fault handling data represents a preset troubleshooting process for the target fault; obtaining reference information corresponding to each troubleshooting node in the preset troubleshooting process based on the fault handling data; and generating troubleshooting text based on the reference information corresponding to each troubleshooting node.

[0155] According to one or more embodiments of this disclosure, the fault handling data includes component identifiers of node components corresponding to each troubleshooting node, and the node components are used to implement the processing functions corresponding to the troubleshooting node; when the generation module obtains reference information corresponding to each troubleshooting node in the preset troubleshooting process based on the fault handling data, it is specifically used to: based on the preset troubleshooting process represented by the fault handling data, sequentially call the node components corresponding to each troubleshooting node to obtain the system reference information corresponding to the troubleshooting node; wherein, the reference information includes at least one of the following: system operating status information, user feedback information, and system external information.

[0156] According to one or more embodiments of this disclosure, when the generation module generates troubleshooting text based on the response text, it is specifically configured to: obtain fault phenomenon data based on the response text, wherein the fault phenomenon data is used to describe the system operation phenomenon corresponding to the target fault; query a fault database based on the fault phenomenon data to obtain troubleshooting step text, wherein the fault database contains system operation phenomena of preset types and corresponding troubleshooting steps; and arrange the troubleshooting step text based on a language model to generate the troubleshooting text.

[0157] According to one or more embodiments of this disclosure, after generating the troubleshooting text, the generation module is further configured to: store the fault description text, the troubleshooting text, and the corresponding dialogue data in the fault database, wherein the dialogue data includes interactive text and corresponding response text.

[0158] Thirdly, according to one or more embodiments of the present disclosure, an electronic device is provided, comprising: at least one processor and a memory;

[0159] The memory stores computer-executed instructions;

[0160] The at least one processor executes computer execution instructions stored in the memory, causing the at least one processor to perform the interactive system troubleshooting method as described in the first aspect and various possible designs of the first aspect.

[0161] Fourthly, according to one or more embodiments of the present disclosure, a computer-readable storage medium is provided, wherein computer-executable instructions are stored therein, and when a processor executes the computer-executable instructions, the interactive system troubleshooting method described in the first aspect and various possible designs of the first aspect is implemented.

[0162] Fifthly, according to one or more embodiments of the present disclosure, a computer program product is provided, including a computer program that, when executed by a processor, implements the interactive system troubleshooting method described in the first aspect and various possible designs of the first aspect.

[0163] The above description is merely a preferred embodiment of this disclosure and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of this disclosure is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features disclosed in this disclosure that have similar functions.

[0164] Furthermore, while the operations are described in a specific order, this should not be construed as requiring these operations to be performed in the specific order shown or in a sequential order. In certain environments, multitasking and parallel processing may be advantageous. Similarly, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of this disclosure. Certain features described in the context of individual embodiments may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented individually or in any suitable sub-combination in multiple embodiments.

[0165] Although the subject matter has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative examples of implementing the claims.

Claims

1. An interactive system troubleshooting method, characterized in that, include: Obtain the fault description text for the target fault; The fault description text is processed by a language model to generate interactive text, and a response text is obtained for the interactive text. The interactive text is used to indicate at least one target detection action, the target detection action is used to detect at least one operating state of the system, and the response text is used to characterize the detection result of the target detection action. Based on the response text, a troubleshooting text is generated, which describes a troubleshooting solution for the target fault.

2. The method according to claim 1, characterized in that, The process of processing the fault description text using a language model to generate interactive text and obtaining response text for the interactive text includes: Obtain the information extraction node corresponding to the fault description text. The information extraction node is a preset functional unit used to generate interactive text after being triggered. The information extraction node includes first node information, which is used to characterize the generation rules of the interactive text. The information extraction node generates interactive text corresponding to the fault description text and obtains response text for the interactive text.

3. The method according to claim 2, characterized in that, The first node information of the information extraction node includes key text information and corresponding descriptive information. The key text information is used to characterize the detection keywords corresponding to the target detection action; the descriptive information is used to characterize the rules for constructing the corresponding interactive text by combining the detection keywords.

4. The method according to claim 2, characterized in that, The information extraction nodes are at least two, the interactive text includes multiple interactive sub-texts obtained based on different information extraction nodes, the response text includes response sub-texts corresponding to the interactive sub-texts, and the information extraction nodes also include second node information, which is used to characterize the processing rules for jumping to the next information extraction node based on the interactive sub-texts.

5. The method according to claim 4, characterized in that, The step of generating interactive text corresponding to the fault description text through the information extraction node and obtaining response text for the interactive text includes: Repeat the following steps until the stopping condition is triggered: Based on the information of the first node within the current information extraction node, generate the corresponding interactive sub-text; The current information extraction node receives the response subtext corresponding to the interactive subtext. Based on the second node information within the current information extraction node and the response subtext, determine the jump information extraction node of the current information extraction node; Update the current information extraction node to the jump information extraction node, and return to the step of generating the corresponding interactive sub-text based on the first node information within the current information extraction node.

6. The method according to claim 5, characterized in that, The step of determining the jump information extraction node of the current information extraction node based on the second node information within the current information extraction node and the response subtext includes: Based on the second node information, the field value of the target field in the response subtext is obtained, and the target field represents the target detection action; The jump information extraction node is determined based on the field value of the target field.

7. The method according to claim 5, characterized in that, After receiving the response subtext corresponding to the interactive subtext through the current information extraction node, the method further includes: Save the response subtext; and / or, Obtain the detection results of the target detection action represented by the response subtext generated in at least two loop rounds, and trigger the stopping condition based on at least two of the detection results; The step of generating troubleshooting text based on the response text includes: The troubleshooting text is generated based on the detection results corresponding to each of the aforementioned response sub-texts.

8. The method according to claim 1, characterized in that, The step of generating troubleshooting text based on the response text includes: Based on the private domain language model, semantic recognition is performed on the response text to obtain fault handling data corresponding to the target fault. The fault handling data represents the preset troubleshooting process for the target fault. Based on the fault handling data, reference information corresponding to each troubleshooting node in the preset troubleshooting process is obtained; Based on the reference information corresponding to each obstacle removal node, generate obstacle removal text.

9. The method according to claim 8, characterized in that, The fault handling data includes the component identifier of the node component corresponding to each fault clearing node, and the node component is used to implement the processing function corresponding to the fault clearing node. The step of obtaining reference information corresponding to each troubleshooting node in the preset troubleshooting process based on the fault handling data includes: Based on the preset troubleshooting process characterized by the fault handling data, the node components corresponding to each troubleshooting node are called sequentially to obtain the system reference information corresponding to the troubleshooting node. The reference information includes at least one of the following: system operating status information, user feedback information, and external system information.

10. The method according to claim 1, characterized in that, The step of generating troubleshooting text based on the response text includes: Based on the response text, fault phenomenon data is obtained, which is used to describe the system operation phenomenon corresponding to the target fault. Based on the fault phenomenon data, the fault database is queried to obtain the troubleshooting steps text. The fault database contains system operation phenomena of preset types and corresponding troubleshooting steps. The troubleshooting steps text is arranged based on a language model to generate the troubleshooting text.

11. The method according to claim 10, characterized in that, After generating the troubleshooting text, the method further includes: The fault description text, the troubleshooting text, and the corresponding dialogue data are stored in the fault database, wherein the dialogue data includes interactive text and corresponding response text.

12. An interactive system troubleshooting device, characterized in that, include: The acquisition module is used to acquire the fault description text for the target fault; The processing module is used to process the fault description text through a language model, generate interactive text, and obtain response text for the interactive text, wherein the interactive text is used to indicate at least one target detection action, the target detection action is used to detect at least one operating state of the system, and the response text is used to characterize the detection result of the target detection action. The generation module is used to generate troubleshooting text based on the response text, wherein the troubleshooting text describes a troubleshooting solution for the target fault.

13. An electronic device, characterized in that, include: Processor and memory; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory, causing the processor to perform the interactive system troubleshooting method as described in any one of claims 1 to 11.

14. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when executed by the processor, implement the interactive system troubleshooting method as described in any one of claims 1 to 11.

15. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by the processor, it implements the interactive system troubleshooting method as described in any one of claims 1 to 11.

Images