Computer implementations, computer programs, and computer systems for generating error event descriptions (generating error event descriptions using context-specific attention).

Abstract

To provide a computer-implemented method, computer program product, and computer system for generating error event descriptions using context-specific attention.SOLUTION: A method comprises: receiving a set of error messages associated with an error event; generating a tokenization of at least one line of the set of error messages; providing the tokenization to an attention head according to a context of the tokenization; providing an output of the attention head as input to a generative model; generating a description of the error event according to the output; and providing the description to a user to generate error event descriptions.SELECTED DRAWING: Figure 7

Description

Technical Field

[0001] The present disclosure generally relates to machine learning-based generation of error event descriptions. The present disclosure particularly relates to machine learning-based generation of error event descriptions that support an integrated development environment (IDE).

Background Art

[0002] Current support for technical chatbots helps to configure services for common IT tasks such as account provisioning / deprovisioning, password help, hooking into problem-solving systems, and creating support tickets to delegate problems to human agents.

Summary of the Invention

Problems to be Solved by the Invention

[0003] Provided are a computer-implemented method, a computer program product, and a computer system for generating an error event description using context-specific attention.

Means for Solving the Problems

[0004] The following presents an overview for providing a basic understanding of one or more embodiments of the present disclosure. This overview is not intended to identify key or critical elements or to define any scope of any particular embodiment or any scope of the claims. Its sole purpose is to present concepts in a simplified form as a prelude to the more detailed description that is presented later. In one or more embodiments described herein, a device, system, computer-implemented method, apparatus, or computer program product or a combination thereof enables error event description generation.

[0005] Aspects of the present invention disclose a method, system, and computer-readable medium relating to receiving a set of error messages related to an error event; generating a tokenization of at least one line of the set of error messages; providing the tokenization to an attention head according to the context of the tokenization; providing the output of the attention head as input to a generation model; generating a description of the error event according to the output; and generating a description of the error event by providing the description to a user.

[0006] Through a more detailed description of some embodiments of the present disclosure in the accompanying drawings, the above and other purposes, features and advantages of the present disclosure will become more apparent, where the same references generally refer to the same components in embodiments of the present disclosure. [Brief explanation of the drawing]

[0007] [Figure 1] This figure shows a schematic representation of a computing environment according to an embodiment of the present invention. [Figure 2] This flowchart shows data tokenization and dispatch to each attention head according to an embodiment of the present invention. [Figure 3] This is a functional block diagram of row-based attention according to an embodiment of the present invention. [Figure 4] This is a functional block diagram of error-based attention according to an embodiment of the present invention. [Figure 5] This is a functional block diagram of variable-based attention according to an embodiment of the present invention. [Figure 6] This is a block diagram of a coupled attention head and a generative language model according to an embodiment of the present invention. [Figure 7] This is a flowchart showing the operation sequence according to an embodiment of the present invention. [Figure 8] This figure shows a cloud computing environment according to an embodiment of the present invention. [Figure 9]This figure shows an abstraction model layer according to an embodiment of the present invention. [Modes for carrying out the invention]

[0008] Some embodiments are described in more detail with reference to the accompanying drawings illustrating embodiments of the present disclosure. However, the present disclosure can be implemented in various ways and should not be construed as being limited to the embodiments disclosed herein.

[0009] For complex tasks requiring deep technical skills, there is a gap between the capabilities of current chatbot applications and user needs. The disclosed embodiment provides a chatbot that uses conversational AI to understand problems, perform intelligent searches to find solutions, and suggest appropriate solutions in conversational threads. If a solution cannot be found, the chatbot records the problem as a skills gap for later training and hands the problem over to a human agent to close the loop.

[0010] When resolving programming errors, technical experts spend most of their time understanding the stack trace of the error message. The disclosed embodiment focuses on accelerating this process by helping technical experts understand the core of the error message. The disclosed method provides a chatbot integrated into the development environment that proactively scans for error events. When an error event occurs, the chatbot uses a context-specific attention mechanism to parse the stack trace of the error message and gather details such as the line number of the program code that caused the error, the variables involved, and a description of the error. A global attention head based on a pre-trained generative language model combines these details from the context-specific attention head, along with other information from a knowledge base that facilitates the resolution of the programming error, to generate a user-friendly conversational description of the error message.

[0011] Programming errors are an integral part of the application development process. The disclosed embodiments accelerate the error resolution process by automating the description of error events and outlining the steps required to resolve the error using conversational dialogs. This can accelerate the application development timeline.

[0012] Aspects of the present invention generally relate to a chatbot system, and more particularly to conversational assistance regarding coding errors in an integrated development environment. In embodiments, the chatbot system receives error display and error stack trace messages from a user device, determines the error context from the stack trace, and returns generated conversational output that includes not only the error context but also additional information related to the error identified from the context. According to aspects of the present invention, the chatbot system automatically removes irrelevant parts of the stack trace, extracts relevant data from lines of the stack trace, retrieves stored data related to the identified error, and generates a conversational response to the user. The chatbot system receives follow-up questions from the user regarding the output and continuously builds a knowledge store of potential errors and useful responses to those errors. In this way, implementations of the present invention learn and continuously adjust the relevant knowledge store so that the chatbot system returns answers that help the user quickly resolve and eliminate coding errors.

[0013] According to an aspect of the present invention, there is a method for automatically generating conversational output related to a current coding error, the method comprising: receiving an error message containing a multi-line stack trace for the error; parsing the multi-line message to remove irrelevant lines from the message; tokenizing the remaining lines to determine the context for each remaining line, e.g., line number, variables, and error description; passing the tokenizations for each remaining line to a context-specific attention head for evaluation; passing the combined output of the multiple attention heads to a global language generator; and passing the generated conversational output of the global language generator to a user of the system.

[0014] Aspects of the present invention provide improvements in the field of chatbot systems. Conventional chatbot systems utilize static models when determining what answers to provide to questions posed by users. Often, users do not have prior data to tell them what questions based on relevant errors might be. An implementation of the present invention parses the system's error messages, determines the context of the relevant parts of the message, and generates a response related to the identified error context, including the next steps suggested, which are retrieved from the system's knowledge store in relation to the identified error. This provides improvements in identifying the location and nature of coding errors for the user and in providing useful information on how to resolve the errors.

[0015] Aspects of the present invention also provide improvements to the functionality of computers. In particular, implementations of the present invention are directed toward specific improvements to how chatbot systems operate, specifically demonstrated in the parsing of stack trace messages and evaluation of message lines using context-specific attention heads to extract relevant data to generate conversational output that assists the user in identifying and resolving the current coding error. In embodiments, the system determines the context of each relevant line of the stack trace and passes each line to a specific attention head according to the context identified for that line. The separate attention heads extract specific data from the stack trace lines and pass the combined data portion to a generation model where conversational messages are generated based on the extracted data and relating to the current error. The method delivers the generated messages to the user and engages the user in further conversation related to resolving the error.

[0016] In summary, a chatbot system is an artificial intelligence application that runs on data processing hardware and generates natural language responses to input data on a given subject. The chatbot system receives input from various sources, including input via a network, a corpus of electronic documents or other data, data from content creators, information from one or more content users, and such input from other possible input sources. A data storage device stores the corpus data. A response generator generates responses according to a trained model and the received input data. For example, a chatbot system accesses a knowledge base on a domain or subject area (e.g., error messages for a particular programming language). Here, the knowledge base can be organized in various configurations and is not limited to, for example, a structured repository of programming language-specific information, such as known error message descriptions and typical solutions to such error messages.

[0017] In embodiments, one or more components of the system may use hardware, software, or both to solve problems that are inherently highly technical (e.g., receiving a set of error messages related to an error event, generating a tokenization of at least one line of the set of error messages, providing the tokenization to an attention head according to the context of the tokenization, providing the output of the attention head as input to a generative model, generating a description of the error event according to the output, providing the description to the user, etc.). These solutions are not abstract and cannot be performed as a series of mental actions by a human, for example, due to the processing power required to facilitate the resolution of the error event. Furthermore, some of the processing to be performed may be carried out by a dedicated computer for performing defined tasks related to the resolution of the error event. For example, a dedicated computer may be employed to perform tasks related to the resolution of the error event.

[0018] Figure 1 is a schematic diagram showing exemplary network resources related to the implementation of the disclosed invention. The invention may be implemented in a processor of any of the disclosed elements that processes instruction streams. As shown in the figure, a networked client device 110 connects wirelessly to the server subsystem 102. A client device 104 connects wirelessly to the server subsystem 102 via the network 114. Client devices 104 and 110 constitute an error event evaluation program (not shown) along with sufficient computing resources (processor, memory, network communication hardware) to run the program. Client devices 104 and 110 represent user interface devices for an IDE user to enter code into the IDE and engage with a chatbot of the disclosed embodiment regarding code error events. As shown in Figure 1, the server subsystem 102 comprises a server computer 150. Figure 1 shows a block diagram of the components of the server computer 150 in a networked computer system 1000 according to an embodiment of the invention. It should be understood that Figure 1 provides only an example of one implementation and does not imply any limitations with respect to environments in which different embodiments may be implemented. Many modifications can be made to the depicted environment.

[0019] The server computer 150 may include a processor 154, memory 158, persistent storage 170, a communication unit 152, an input / output (I / O) interface 156, and a communication fabric 140. The communication fabric 140 provides communication between the cache 162, memory 158, persistent storage 170, communication unit 152, and the input / output (I / O) interface 156. The communication fabric 140 can be implemented in any architecture designed to pass data or control information, or both, between the processor (such as a microprocessor, communication and network processor), system memory, peripherals, and any other hardware components in the system. For example, the communication fabric 140 can be implemented using one or more buses.

[0020] Memory 158 and persistent storage 170 are computer-readable storage media. In this embodiment, memory 158 includes random access memory (RAM) 160. Generally, memory 158 can include any suitable volatile or non-volatile computer-readable storage media. Cache 162 is a high-speed memory that improves the performance of processor 154 by holding recently accessed data and data near recently accessed data from memory 158.

[0021] Program instructions and data used to practice embodiments of the present invention, such as error event description generation program 175, are stored in persistent storage 170 for execution or access or both by one or more of the respective processors 154 of server computer 150 via cache 162. In this embodiment, persistent storage 170 includes a magnetic hard disk drive. Alternatively, or in addition to a magnetic hard disk drive, persistent storage 170 can include a solid state hard disk, a semiconductor memory device, a read only memory (ROM), an erasable programmable read only memory (EPROM), a flash memory, or any other computer-readable storage media capable of storing program instructions or digital information.

[0022] Also, the media used by persistent storage 170 may be removable. For example, a removable hard disk may be used for persistent storage 170. Other examples include optical disks and magnetic disks, thumb drives, and smart cards that are inserted into a drive for transfer onto another computer-readable storage media that is also part of persistent storage 170.

[0023] In these examples, the communication unit 152 provides communication with other data processing systems or devices, including the resources of client computing devices 104 and 110. In these examples, the communication unit 152 includes one or more network interface cards. The communication unit 152 can provide communication through the use of either or both physical and wireless communication links. Software distribution programs and other programs and data used in the implementation of the present invention may be downloaded through the communication unit 152 to the persistent storage 170 of the server computer 150.

[0024] The I / O interface 156 enables data input and output with other devices that may be connected to the server computer 150. For example, the I / O interface 156 can provide connection to an external device 190 such as a keyboard, keypad, touchscreen, microphone, digital camera, or other suitable input device or combination thereof. The external device 190 may also include portable computer-readable storage media such as thumb drives, portable optical or magnetic disks, and memory cards. Software and data used to practice embodiments of the present invention, such as an error event description generation program 175 on the server computer 150, can be stored on such portable computer-readable storage media and loaded into persistent storage 170 via the I / O interface 156. The I / O interface 156 also connects to a display 180.

[0025] The display 180 provides a mechanism for displaying data to the user and may be, for example, a computer monitor. The display 180 can also function as a touchscreen, such as the display of a tablet computer, to provide the user with a display of the entered code and the ongoing code error conversation with the chatbot of the disclosed invention.

[0026] Referring to Figure 2, in this embodiment, in block 210, the user begins using the chatbot system and method. After initiation, the system and method begins scanning the user's IDE and detects an error event with a relevant stack trace error message. The method and system receives the stack trace for the error event. In this embodiment, in block 220, the method parses the stack trace and considers each line of the message individually. For each line, in block 230, the method tokenizes the line by dividing it into individual words or individual characters in a language such as English, French, or German.

[0027] In this embodiment, in block 240, the method filters the stack trace line to exclude lines that do not refer to line numbers, variables, or error event descriptions from further consideration and processing. Similarly, in block 250, the method further filters the stack trace line to exclude lines that refer to line numbers outside the scope of the error event evaluator, such as lines related to code from an import library, from further consideration. In block 260, the method applies a token frequency count to the tokens of the remaining lines to determine the relevant context of the remaining lines, e.g., lines, variables, or error descriptions (errors).

[0028] Next, each tokenization of the remaining lines is passed to the appropriate attention head of the system for further processing, such as identifying specific lines, variables, and error descriptions contained in the tokenization of the stack trace line. Those stack trace lines with frequency counts indicating the presence of the relevant line numbers are passed to the line attention head in block 270. Those with frequency counts indicating variables are passed to the variable attention head in block 280, and those with frequency counts indicating error codes or other error descriptions are passed to the error attention head in block 290.

[0029] In embodiments, the method further processes the stack trace line using one or more weighted linear transformation functions to convert the tokenization of the original lines into vectors having a common dimension. The vectors output from the linear transformation functions are then passed to context-specific attention as described below. In embodiments, the vectors have a consistent dimension due to the linear transformation functions.

[0030] Figure 3 illustrates the functionality of the row attention head. In embodiments, the use of a specific architecture for the attention head benefits from including information about the relative positioning of each token for the stack trace line in the input. To this end, the method defines positional information, such as positional information relative to the dimensions of the token embeddings in the stack trace line, according to positional functions for different dimensions, such as using sine and cosine functions to define positional data for each element of the input tokenization. In embodiments, each context-specific attention head includes an encoder-decoder architecture. As shown in the figure, the method passes the tokenization LT of the stack trace line, along with the determined positional information PE for tokenization, to the encoder 310 and decoder 320 modules of the row attention head 300. The encoder 310 performs row tokenization from the stack trace by stacking multi-head attention 312 and feedforward logic 314 six times as one block. On the decoder 320 side, the setup is similar to that of the encoder 310, with the addition of a row-specific attention block 322 that appears to extract row number information as the decoder output. This method combines row-based attention outputs with encoder 310 outputs, with inputs to six block structures featuring multi-head attention 324 and feedforward logic 326, similar to those used in encoder 310.

[0031] In this embodiment, the encoder has a configuration of stacking identical layers, such as six identical layers. Each layer has a multi-head self-attention head 312, a sublayer, and a positionally fully connected feedforward network 314, a sublayer. The encoder also includes connections around the multi-head attention and the feedforward network, respectively. The output of each sublayer is normalized.

[0032] In this embodiment, the decoder also has a configuration consisting of six identical layers stacked on top of each other. Each decoder layer includes the two sublayers described above, plus a context-specific attention head. The decoder output is also normalized. Both the encoder and the decoder receive the same embedding of context-relevant tokenization.

[0033] In one embodiment, the attention head consists of a scaled dot product attention function between words in a sentence to quantify the relationships between words in the sentence. Furthermore, the attention head is multi-head attention because it uses multiple attention functions in parallel. This allows the model to jointly pay attention to different representational subspaces at different locations.

[0034] In one embodiment, the feedforward network consists of a neural network that applies two linear transformations with normalized linear unit (ReLU) activations in between to inject nonlinearity.

[0035] In one embodiment, the output from the decoder is passed to a linear transformation function LINEAR, which generates an input for a softmax function SM. The output of the softmax function SM is passed to a global attention head and a generative language model.

[0036] In one embodiment, the linear transformation function consists of the same function and function weights used to transform the context embeddings from the input tokenization into vectors of the desired dimensions, where the linear transformation transforms the decoder output into vectors of the same dimensions.

[0037] In one embodiment, the softmax function transforms the vector output of the linear transformation function into a normalized probability distribution of the next token prediction, according to the corpus on which the system and method are based.

[0038] Figure 4 shows the functionality of the variable attention head. In the embodiment, the use of a particular architecture for the attention head benefits from including information about the relative positioning of each token for the stack trace line in the input. To this end, the method defines positional information such as positional information relative to the dimensions of the token embeddings in the stack trace line according to positional functions for different dimensions, such as using sine and cosine functions to define positional data for each element of the input tokenization. As shown in the figure, the method passes the tokenized stack trace line LT, along with the determined positional information PE, to the encoder 410 and decoder 420, respectively, which are modules of the variable attention head 400, for tokenization. The encoder 410 performs variable tokenization from the stack trace by repeating the multi-head attention 412 and feedforward logic 414 as one block six times and stacking them. On the decoder 420 side, the setup is similar to that of the encoder 410, with the addition of a variable-specific attention block 422 that appears to extract variable information as the decoder output. This method then combines the variable-based attention output and the encoder 410 output as inputs to a six-block structure that includes a multi-head attention 424 similar to that used in the encoder 410, and a feedforward logic 426.

[0039] In this embodiment, the encoder has a configuration of stacking identical layers, such as six identical layers. Each layer has a multi-head self-attention head 412, a sublayer, and a positionally fully connected feedforward network 414, a sublayer. The encoder also includes connections around the multi-head attention and the feedforward network, respectively. The output of each sublayer is normalized by a normalization function N.

[0040] In this embodiment, as a non-limiting example, the decoder also has a configuration of stacking six identical layers. Each decoder layer includes the two sublayers described above, plus a context-specific attention head. The decoder output is also normalized. The decoder also includes connections around the context-specific attention, multi-head attention, and feedforward networks to the normalization function, respectively. Both the encoder and decoder receive identical embeddings of context-relevant tokenization.

[0041] In one embodiment, the output from the decoder is passed to a linear transformation function LINEAR, which generates an input for a softmax function SM. The output of the softmax function SM is passed to a global attention head and a generative language model.

[0042] Figure 5 is a diagram illustrating the functionality of the error attention head. In the embodiment, the use of a particular architecture for the attention head can benefit from including information about the relative positioning of each token for the stack trace line in the input. To this end, the method defines positional information, such as positional information relative to the dimensions of the token embeddings in the stack trace line, according to positional functions for different dimensions, such as using sine and cosine functions to define positional data for each element of the input tokenization. As shown in the figure, the method passes the tokenized stack trace error ET, along with the determined positional information PE for tokenization, to the encoder 510 and decoder 520, respectively, which are modules of the error attention head 500. The encoder 510 performs error tokenization from the stack trace by repeating the multi-head attention 512 and feedforward logic 514 six times as one block and stacking them. On the decoder 520 side, the setup is similar to that of the encoder 510, with the addition of an error-specific attention block 522 that appears to extract error description information as the decoder output. This method combines the error-based attention output with the output of the encoder 510, with the output of the encoder 510 as input to a six-block structure that includes a multi-head attention 524 and feedforward logic 526, similar to those used in the encoder 510.

[0043] In this embodiment, the encoder has a configuration of stacking identical layers, such as six identical layers. Each layer has a multi-head self-attention head 512, a sublayer, and a positionally fully connected feedforward network 514, a sublayer. The encoder also includes connections around the multi-head attention and the feedforward network, respectively. The output of each sublayer is normalized by a normalization function N.

[0044] In this embodiment, as a non-limiting example, the decoder also has a configuration of stacking six identical layers. Each decoder layer includes the two sublayers described above, plus a context-specific attention head. The decoder output is also normalized. The decoder also includes connections around the context-specific attention, multi-head attention, and feedforward networks to the normalization function, respectively. Both the encoder and decoder receive identical embeddings of context-relevant tokenization.

[0045] In one embodiment, the output from the decoder is passed to a linear transformation function LINEAR, which generates an input for a softmax function SM. The output of the softmax function SM is passed to a global attention head and a generative language model.

[0046] Figure 6 shows a global attention head 600 that receives and combines the outputs of row, variable, and error attention heads. The global attention head utilizes a trained generative model, such as a GPT-3 model, to generate conversational outputs based on the received row, variable, and error outputs. As shown in the figure, each context-specific attention 610, 620, and 630 provides specific outputs 615, 625, and 635. Each of the three outputs is combined in an input vector embedding 640, which the method provides as input to a generative model 650. The generative model 650 outputs a number of potential conversational responses based on the context-dependent input. The method passes the set of outputs and the generative model confidence score corresponding to each output to a softmax function 660, which outputs the probability of words from the model's knowledge corpus used to construct conversational language messages for the system user. In an embodiment, the method then provides the user with the output having the highest confidence score in response to an error event. In an embodiment, the method passes the generated outputs to a trained question-answering system (not shown) to generate specific answers related to the identified error problem. In this embodiment, training the question-answering system includes providing the system with training on known errors in different programming languages ​​so that the trained model can acquire data related to errors identified in the generated responses.

[0047] In this embodiment, the user engages with the chatbot program in response to the generated error description and suggested path. In this embodiment, the method processes the user's response to the generated error description and updates the generative model using output embedding from processing the user's response.

[0048] Figure 7 shows a flowchart 700 illustrating exemplary operation related to the implementation of this disclosure. After the program starts, in block 710, the error event description generation program 175 receives error event data, such as stack trace data for an IDE error event. The program parses the error data into individual lines and filters the lines by discarding lines that are irrelevant to the line number, variable, or error description, and also discarding lines that are outside the scope of the program, such as lines related to code import libraries.

[0049] In block 720, the method generates tokenized embedding vectors for each remaining row. The method performs frequency counts on the tokenizations to determine the context of each row (e.g., row, variable, or error).

[0050] In block 730, the method passes the embedded tokenization to a contextually relevant attention head, such as between lines, for further processing. The attention head extracts specific contextual details from the input embedding as its output, such as line 5, variable A[5], or error description list_index_out_of_range.

[0051] In block 740, the method provides the output of an attention head to a generative model, such as a GPT-3 model. The generative language model generates a conversational output response based on the contextual output from a particular attention head. In one embodiment, the method provides multiple attention head outputs associated with a single stack trace input to a generative language model that produces a conversational output based on the provided set of inputs.

[0052] In block 750, the method provides the user with a generated response related to the current error event. In one embodiment, the method passes the generated response to a question-answering system that generates a conversational response specific to the identified error in the generated output. In this embodiment, the generated question-answer output provides the user with instructions on the steps to take to resolve the current error.

[0053] While this disclosure includes a detailed description of cloud computing, it should be understood that implementations of the teachings described herein are not limited to cloud computing environments. Rather, embodiments of the present invention can be implemented in combination with any other type of computing environment that is currently known or may be developed in the future.

[0054] Cloud computing is a service delivery model that enables convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and deployed with minimal administrative effort or interaction with service providers. This cloud model may include at least five characteristics, at least three service models, and at least four implementation models.

[0055] The characteristics are as follows:

[0056] On-demand self-service: Cloud consumers can unilaterally prepare computing power, such as server time and network storage, automatically as needed, without requiring human interaction with service providers.

[0057] Broad network access: Computing power is available over the network and accessible through standard mechanisms. This facilitates utilization by heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, PDAs).

[0058] Resource pooling: A provider's computing resources are pooled and delivered to multiple consumers using a multi-tenant model. Various physical and virtual resources are dynamically allocated and reallocated as needed. Generally, consumers have a sense of location independence because they do not manage or know the exact location of the resources provided. However, consumers may be able to identify the location at a higher level of abstraction (e.g., country, state, data center).

[0059] Rapid Elasticity: Computing power can be prepared quickly and flexibly, allowing it to scale out automatically and immediately, and to be quickly released and scale in immediately. To consumers, the computing power available for preparation often appears unlimited and can be purchased in any quantity at any time.

[0060] Measured Services: Cloud systems leverage metric capabilities at a certain level of abstraction, appropriate for the type of service (e.g., storage, processing, bandwidth, active user accounts), to automatically control and optimize resource usage. Resource usage can be monitored, controlled, and reported, providing transparency to both service providers and consumers.

[0061] The service model is as follows:

[0062] Software as a Service (SaaS): The functionality offered to consumers is the ability to use the provider's applications running on a cloud infrastructure. These applications can be accessed from various client devices via thin client interfaces such as web browsers (e.g., webmail). Consumers do not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or even individual application functions, except for configuring a limited number of user-specific applications.

[0063] Platform as a Service (PaaS): The functionality offered to consumers is the ability to deploy applications they have created or acquired to cloud infrastructure using programming languages ​​and tools supported by the provider. Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, and storage, but they can control the deployed applications and, in some cases, the configuration of their hosting environment.

[0064] Infrastructure as a Service (IaaS): The functionality provided to consumers is the provision of processing, storage, networking, and other basic computing resources that enable consumers to deploy and run any software, including operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but they can control the operating system, storage, and deployed applications, and in some cases, partially control certain network components (e.g., host firewalls).

[0065] The deployment model is as follows:

[0066] Private Cloud: This cloud infrastructure is operated exclusively for a specific organization. This cloud infrastructure can be managed by that organization or a third party and can reside on-premises or off-premises.

[0067] Community Cloud: This cloud infrastructure is shared by multiple organizations to support a specific community with common interests (e.g., mission, security requirements, policies, and compliance). This cloud infrastructure can be managed by the organization or a third party and can reside on-premises or off-premises.

[0068] Public Cloud: This cloud infrastructure is provided to a large number of people or large industry groups and is owned by organizations that sell cloud services.

[0069] Hybrid Cloud: This cloud infrastructure combines two or more cloud models (private, community, or public). While maintaining the unique entities of each model, they are bound together by standards or individual technologies to achieve data and application portability (e.g., cloud bursting for load balancing across clouds).

[0070] Cloud computing environments are service-oriented environments that emphasize statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing is the infrastructure, which includes a network of interconnected nodes.

[0071] Here, Figure 8 shows an exemplary cloud computing environment 50. As shown in the figure, the cloud computing environment 50 includes one or more cloud computing nodes 10. Local computer devices used by cloud consumers (e.g., PDAs or mobile phones 54A, desktop computers 54B, laptop computers 54C, or automotive computer systems 54N, or a combination thereof) can communicate with these nodes. The nodes 10 can communicate with each other. The nodes 10 can be grouped physically or virtually (not shown) in one or more networks, such as the private, community, public, or hybrid clouds or a combination thereof. This allows the cloud computing environment 50 to provide infrastructure, platforms, or software as a service, or a combination thereof, without requiring cloud consumers to maintain resources on their local computer devices. Note that the types of computer devices 54A-N shown in Figure 8 are merely examples, and it should be understood that the computing nodes 10 and the cloud computing environment 50 can communicate with any type of electronic device via any type of network or network addressable connection (e.g., using a web browser) or both.

[0072] Here, Figure 9 shows a set of functional abstraction layers provided by the cloud computing environment 50 (Figure 8). It should be understood that the components, layers, and functions shown in Figure 9 are merely illustrative, and the embodiments of the present invention are not limited to these. As illustrated, the following layers and corresponding functions are provided.

[0073] The hardware and software layer 60 includes hardware components and software components. Examples of hardware components include a mainframe 61, a reduced instruction set computer (RISC) architecture-based server 62, server 63, blade server 64, storage 65, and a network and network components 66. In some embodiments, the software components include network application server software 67 and database software 68.

[0074] The virtualization layer 70 provides an abstraction layer. From this layer, for example, the following virtual entities can be provided: virtual servers 71, virtual storage 72, virtual networks 73 including virtual private networks, virtual applications and operating systems 74, and virtual clients 75.

[0075] As an example, the management layer 80 can provide the following functions: Resource preparation 81 enables the dynamic procurement of computing resources and other resources used to perform tasks within the cloud computing environment. Metering and pricing 82 enables cost tracking as resources are used within the cloud computing environment and billing or invoicing for the consumption of these resources. As an example, these resources may include licenses for application software. Security enables not only protection of data and other resources, but also identification and verification of cloud consumers and tasks. The user portal 83 provides consumers and system administrators with access to the cloud computing environment. Service level management 84 enables the allocation and management of cloud computing resources to ensure that requested service levels are met. Service Level Agreement (SLA) planning and execution 85 enables the pre-arrangement and procurement of cloud computing resources that are expected to be needed in the future in accordance with the SLA.

[0076] Workload layer 90 provides examples of the capabilities available to the cloud computing environment. Examples of workloads and capabilities available from this layer include mapping and navigation 91, software development and lifecycle management 92, virtual classroom education delivery 93, data analysis processing 94, transaction processing 95, and error event description generation programs 175.

[0077] The present invention may be a system, method, or computer program product or combination thereof, integrated at any possible level of technical detail. The present invention can be beneficially implemented in any single or parallel system that processes instruction streams. The computer program product may include a computer-readable storage medium storing computer-readable program instructions for causing a processor to perform aspects of the present invention.

[0078] A computer-readable storage medium can be a tangible device capable of holding and storing instructions used by an instruction execution device. Examples of computer-readable storage media may be electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or appropriate combinations thereof. More specific examples of computer-readable storage media include portable computer diskettes, hard disks, RAM, ROM, EPROM (or flash memory), SRAM, CD-ROM, DVD, memory stick, floppy disk, punch cards, or grooved raised structures, and mechanically encoded devices on which instructions are recorded, and appropriate combinations thereof. Computer-readable storage devices as used herein should not be interpreted as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through optical fiber cables), or electrical signals transmitted through wires.

[0079] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computer device / processor. Alternatively, they can be downloaded to an external computer or external storage device via a network (e.g., the Internet, LAN, WAN, or wireless network, or a combination thereof). The network may include copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers or edge servers, or a combination thereof. A network adapter card or network interface within each computer device / processor receives computer-readable program instructions from the network and transfers them for storage in a computer-readable storage medium in the respective computer device / processor.

[0080] The computer-readable program instructions for performing the operation of the present invention may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, configuration data for integrated circuits, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk and C++, and procedural programming languages ​​such as the "C" programming language or similar programming languages. The computer-readable program instructions can be executed as a standalone software package, either entirely on the user's computer or partially on the user's computer. Alternatively, they can be executed partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network, including LANs and WANs, or it may be connected to an external computer (for example, via the Internet using an Internet service provider). In some embodiments, electronic circuits, including, for example, programmable logic circuits, field-programmable gate arrays (FPGAs), and programmable logic arrays (PLAs), can execute computer-readable program instructions by utilizing state information of computer-readable program instructions in order to customize the electronic circuits for the purpose of performing aspects of the present invention.

[0081] Embodiments of the present invention are described herein with reference to flowcharts or block diagrams, or both, of methods, apparatus (systems), and computer program products according to embodiments of the present invention. Each block in a flowchart or block diagram, or both, and combinations of blocks in a flowchart or block diagram, or both, are executable by computer-readable program instructions.

[0082] The above computer-readable program instructions may be provided to a processor of a general-purpose computer, a dedicated computer, or other programmable data processing device for the purpose of producing a machine. This creates a means for these instructions, executed via the processor of such computer or other programmable data processing device, to perform functions / operations identified in one or more blocks in a flowchart or block diagram, or both. The above computer-readable program instructions may further be stored in a computer-readable storage medium that can be instructed to function in a particular manner to a computer, a programmable data processing device, or other device, or a combination thereof. This constitutes a product in which the computer-readable storage medium containing the instructions includes instructions for performing functions / operations identified in one or more blocks in a flowchart or block diagram, or both.

[0083] Alternatively, a computer execution process may be generated by loading computer-readable program instructions into a computer, another programmable device, or other device, and having a series of operational steps executed on that computer, other programmable device, or other device. This ensures that the instructions executed on the computer, other programmable device, or other device perform functions / operations identified in one or more blocks in a flowchart, block diagram, or both.

[0084] The flowcharts and block diagrams in the drawings of this disclosure illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of instructions containing one or more executable instructions for performing a particular logical function. In some other implementations, the functions shown within a block may be executed in an order different from the order shown in each figure. For example, two consecutively shown blocks may actually be executed simultaneously or substantially simultaneously, or in some cases in reverse order, depending on the functions involved. Each block in a block diagram or flowchart or both, and combinations of multiple blocks in a block diagram or flowchart or both, are executable by a dedicated hardware-based system that performs a particular function or operation, or executes a combination of dedicated hardware and computer instructions.

[0085] References in this specification to “one embodiment,” “an embodiment,” and “an example embodiment” indicate that the described embodiments may include certain features, structures, or characteristics, but not all embodiments necessarily include such features, structures, or characteristics. Furthermore, such phrases do not necessarily refer to the same embodiment. Moreover, if certain features, structures, or characteristics are described in relation to an embodiment, it is understood that any influence on such features, structures, or characteristics in relation to other embodiments, whether explicitly stated or not, is within the knowledge of those skilled in the art.

[0086] The terms used herein are intended solely to describe and not to limit specific embodiments. Where used herein, the singular forms “a,” “an,” and “the” are intended to include the plural form unless the context explicitly indicates otherwise. Where used herein, the terms “comprises” or “comprising” or both specify the presence of a described feature, integer, step, operation, element, or component or combination thereof, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, or groups or combinations thereof.

[0087] The descriptions of various embodiments of the present invention are presented for illustrative purposes only and are not intended to be exhaustive or limitful to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terms used herein have been selected to best describe the principles of the embodiments, the practical application or technical improvement to the art available on the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

Claims

1. A computer implementation method for generating an error event description, wherein the method is One or more computer processors receive a set of error messages related to an error event, The one or more computer processors generate tokenization of at least one line of the set of error messages, The one or more computer processors provide the tokenization to the attention head in accordance with the context of the tokenization, The output of the attention head is provided as input to the generative model by one or more computer processors. The one or more computer processors generate a description of the error event according to the output, A computer implementation method comprising providing the description to a user using one or more computer processors.

2. The computer implementation method according to claim 1, wherein the set of error messages includes a stack trace of the error event.

3. The computer implementation method according to claim 1, wherein the context includes elements selected from a group including row-based attention, variable-based attention, and error-based attention.

4. The computer implementation method according to claim 1, further comprising filtering the set of error messages according to the error message context using one or more computer processors.

5. The one or more computer processors transmit the description to the question answering system, The computer implementation method according to claim 1, further comprising providing the user with an answer from the question answering system using one or more computer processors, wherein the answer is associated with the description.

6. The computer implementation method according to claim 1, wherein the attention head includes an encoder-decoder architecture.

7. The computer implementation method according to claim 1, further comprising determining the context according to the tokenization.

8. A computer program for generating error event descriptions, wherein the computer program is provided to the computer, Receiving a set of error messages related to an error event, To generate a tokenized version of at least one line of the set of error messages, In accordance with the context of the aforementioned tokenization, the tokenization is provided to the attention head, The output of the attention head is provided as input to the generative model, To generate a description of the error event according to the output, A computer program that provides the user with the above description and causes the user to perform the above.

9. The computer program according to claim 8, wherein the set of error messages includes a stack trace of the error event.

10. The computer program according to claim 8, wherein the context includes elements selected from a group including row-based attention, variable-based attention, and error-based attention.

11. The computer program according to claim 8, further causing the computer to filter the set of error messages according to the context.

12. The computer, The above description is passed to the question answering system, The computer program according to claim 8, further comprising providing to the user an answer from the question answering system, wherein the answer is associated with the description.

13. The attention head is a computer program according to claim 8, comprising an encoder-decoder architecture.

14. The computer, The computer program according to claim 8, further comprising causing the program to determine the context in accordance with the tokenization.

15. A computer system for generating error event descriptions, wherein the computer system is One or more computer processors, One or more computer-readable storage devices, The program instructions include program instructions stored on one or more computer-readable storage devices for execution by one or more computer processors, and the stored program instructions include: Receiving a set of error messages related to an error event, To generate a tokenized version of at least one line of the set of error messages, In accordance with the context of the aforementioned tokenization, the tokenization is provided to the attention head, The output of the attention head is provided as input to the generative model, To generate a description of the error event according to the output, A computer system that includes program instructions to provide the above description to a user.

16. The computer system according to claim 15, wherein the set of error messages includes a stack trace of the error event.

17. The computer system according to claim 15, wherein the context includes elements selected from a group including row-based attention, variable-based attention, and error-based attention.

18. The computer system according to claim 15, wherein the stored program instructions further include program instructions for filtering the set of error messages according to the context.

19. The stored program instructions are The above description is passed to the question answering system, The computer system according to claim 15, further comprising a program instruction to provide a response from the question answering system to the user, wherein the response is associated with the description.

20. The attention head includes an encoder-decoder architecture, as described in claim 15.

Images