System with processor, computer-implemented method, and program (synthetic system fault generation)

Abstract

To provide a system, computer-implemented method and computer program product that allow for promoting a composite system failure generation.SOLUTION: A system according to an embodiment may comprise a processor that executes a generator component to generate a composite system failure to be represented as a combination of discrete and continuous parameters defining a system state and a failure assembler component to analyze the composite system failure and generate a text content corresponding to the composite system failure, by utilization of a computer-executable component, namely a trained artificial intelligence (AI) model, stored in a non-transitory computer-readable medium.SELECTED DRAWING: Figure 6

Description

[Technical Field]

[0001] FIELD OF THE DISCLOSURE The present disclosure relates to system faults, and more particularly to synthetic system fault generation. Summary of the Invention [Problem to be solved by the invention]

[0002] System failure data is very limited due to the rarity of events. Many existing technologies for automatically detecting system failures use machine learning (ML) and / or artificial intelligence (AI) methods. A problem with such existing technologies is that the amount of system failure data available for a particular system is often insufficient to apply such ML and / or AI methods. Another problem with such existing technologies is that the quality of the system failure data available for a particular system is often insufficient to apply such ML and / or AI methods. In addition, information technology (IT) data is highly complex, and it is difficult to generate a sufficient amount of high-quality system failure data that can be used by such existing technologies. [Means for solving the problem]

[0003] The following presents a summary to provide a basic understanding of one or more embodiments of the invention. This summary is not intended to identify key or critical elements of particular embodiments or any claims, or to delineate any scope thereof. 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 system, computer-implemented method, or computer program product, or combination thereof, for facilitating synthetic system fault generation is described.

[0004] According to an embodiment, a system may include a processor that executes the following computer-executable components stored on a non-transitory computer-readable medium: a generator component that utilizes a trained artificial intelligence (AI) model to generate synthetic system faults represented as combinations of discrete and continuous parameters that define system states; and a fault assembler component that analyzes the synthetic system faults and generates text content corresponding to the synthetic system faults. An advantage of such a system is that it can generate synthetic system faults that can be used to train one or more AI or ML models, or a combination thereof, to detect one or more previously unknown and / or undetected system faults in a particular system.

[0005] In some embodiments, the computer-executable components further include an aggregator component that generates a knowledge base of the generated synthetic system faults and the respective text data. An advantage of such a system is that it generates a knowledge base that can be used to train one or more AI or ML models, or a combination thereof, to detect one or more previously unknown and / or undetected system faults in a particular system.

[0006] According to another embodiment, a computer-implemented method may include using a processor to utilize a trained artificial intelligence (AI) model to generate synthetic system faults represented as combinations of discrete and continuous parameters that define system states. The computer-implemented method may further include using the processor to analyze the synthetic system faults and generate text content corresponding to the synthetic system faults. Advantageously, such a computer-implemented method may be implemented to generate synthetic system faults that can be used to train one or more AI or ML models, or a combination thereof, to detect one or more previously unknown and / or undetected system faults in a particular system.

[0007] In some embodiments, the above computer-implemented method may further comprise generating, using a processor, a knowledge base of the generated synthetic system faults and the respective text data. Such a computer-implemented method may be advantageously implemented to generate a knowledge base that may be used to train one or more AI or ML models, or a combination thereof, to detect one or more previously unknown and / or undetected system faults in a particular system.

[0008] According to another embodiment, a computer program product includes a computer-readable storage medium having program instructions embodied thereon, the program instructions being executable by a processor to cause the processor to utilize a trained artificial intelligence (AI) model to generate synthetic system faults represented as combinations of discrete and continuous parameters defining system states. The program instructions are further executable by the processor to cause the processor to analyze the synthetic system faults and generate text content corresponding to the synthetic system faults. An advantage of such a computer program product is that it can be implemented to generate synthetic system faults that can be used to train one or more AI or ML models, or a combination thereof, to detect one or more previously unknown and / or undetected system faults in a particular system.

[0009] In some embodiments, the program instructions are further executable by a processor to cause the processor to generate a knowledge base of the generated synthetic system faults and the respective text data. An advantage of such a computer program product is that it generates a knowledge base that can be used to train one or more AI or ML models, or a combination thereof, to detect one or more previously unknown and / or undetected system faults in a particular system. [Brief explanation of the drawings]

[0010] [Figure 1] FIG. 1 illustrates a block diagram of an example non-limiting system that can facilitate synthetic system fault generation according to one or more embodiments described herein. [Figure 2] FIG. 1 illustrates a block diagram of an example non-limiting system that can facilitate synthetic system fault generation according to one or more embodiments described herein.

[0011] [Figure 3] 1 illustrates a flow diagram of an example non-limiting computer-implemented method that can facilitate synthetic system fault generation according to one or more embodiments described herein.

[0012] [Figure 4] FIG. 1 illustrates a block diagram of an example non-limiting system that can facilitate synthetic system fault generation according to one or more embodiments described herein.

[0013] [Figure 5] 10A-10C illustrate non-limiting example diagrams that can facilitate synthetic system fault generation according to one or more embodiments described herein.

[0014] [Figure 6] 1 illustrates a flow diagram of an example non-limiting computer-implemented method that can facilitate synthetic system fault generation according to one or more embodiments described herein. [Figure 7] 1 illustrates a flow diagram of an example non-limiting computer-implemented method that can facilitate synthetic system fault generation according to one or more embodiments described herein.

[0015] [Figure 8] 1 illustrates a block diagram of an example non-limiting operating environment capable of facilitating one or more embodiments described herein.

[0016] [Figure 9]1 illustrates a block diagram of an example non-limiting cloud computing environment in accordance with one or more embodiments of the present disclosure.

[0017] [Figure 10] FIG. 1 illustrates a block diagram of an example of non-limiting abstraction model layers in accordance with one or more embodiments of the present disclosure. DETAILED DESCRIPTION OF THE INVENTION

[0018] The following detailed description is merely exemplary and is not intended to limit the embodiments and / or the application or uses of the embodiments, nor is there any intention to be bound by any express or implied information presented in the preceding Background or Overview section or in the Detailed Description section.

[0019] One or more embodiments will now be described with reference to the drawings. Like reference numerals are used to refer to like elements throughout. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a more thorough understanding of one or more embodiments. It will be apparent, however, that in various instances one or more embodiments may be practiced without these specific details.

[0020] In view of the problems described above with respect to existing techniques for automatically detecting system faults, the present disclosure may be implemented to create a solution to these problems in the form of a system, computer-implemented method, or computer program product, or a combination thereof, that can utilize a trained artificial intelligence (AI) model to generate synthetic system faults represented as combinations of discrete and continuous parameters that define system states, analyze the synthetic system faults, and / or facilitate synthetic system fault generation by generating text content that corresponds to the synthetic system faults. An advantage of such a system, computer-implemented method, or computer program product, or a combination thereof, is that it can be implemented to generate synthetic system faults that can be used to train one or more AI or ML models, or a combination thereof, to detect one or more previously unknown and / or undetected system faults in a particular system.

[0021] In some embodiments, the present disclosure can be implemented to create a solution to the above-described problem in the form of a system, computer-implemented method, or computer program product, or a combination thereof, that can generate a knowledge base of generated synthetic system faults and respective text data. An advantage of such a system, computer-implemented method, or computer program product, or a combination thereof, is that it can be implemented to generate a knowledge base that can be used to train one or more AI or ML models, or a combination thereof, to detect one or more previously unknown and / or undetected system faults in a particular system.

[0022] As referred to herein, a “fault” or “system fault” may describe, for example, a malfunction or failure of one or more components, or a combination thereof, in a system, such as a software system or a hardware system, or a combination thereof (e.g., a classical computing software system or a hardware system, or a combination thereof, a quantum computing software system or a hardware system, or a combination thereof, etc.). As referred to herein, such a “fault” or such a “system fault” may be represented as a combination of discrete and continuous parameters that define the state of such a system, as well as textual data corresponding to and / or describing the “fault” or “system fault” (e.g., a log generated by the system that includes a textual description of the “fault” or “system fault”). As referred to herein, such discrete or continuous parameters, or a combination thereof, may include, for example, a central processing unit (CPU) parameter, an infrastructure parameter, a memory parameter, and / or another parameter of the software system or the hardware system, or both.

[0023] As referred to herein, an "entity" may include a human, a client, a user, a computing device, a software application, an agent, a machine learning (ML) model, an artificial intelligence (AI) model, or a combination of other entities. According to one or more embodiments of the present disclosure described herein, such an entity may implement the synthetic fault generation system 102 or a combination of one or more components thereof (e.g., generator component 108, fault assembler component 110, model trainer component 202, aggregator component 204, etc.).

[0024] 1 illustrates a block diagram of an example non-limiting system 100 that can facilitate synthetic system fault generation according to one or more embodiments described herein. System 100 may include a synthetic fault generation system 102. Synthetic fault generation system 102 may include a memory 104, a processor 106, a generator component 108, a fault assembler component 110, and / or a bus 112.

[0025] It should be appreciated that the embodiments of the present disclosure illustrated in the various figures disclosed herein are for illustrative purposes only, and thus the architecture of such embodiments is not limited to the illustrated systems, devices, or components, or combinations thereof. For example, in some embodiments, system 100 or synthetic fault generation system 102, or combinations thereof, may further include various computers and / or computing-based elements described herein with reference to operating environment 800 and FIG. 8. In embodiments, such computers and / or computing-based elements may be used in connection with implementing one or more of the systems, devices, components, or computer-implemented operations, or combinations thereof, shown and described in connection with FIG. 1 or other figures disclosed herein.

[0026] Memory 104 may store one or more computer- and / or machine-readable, writable, and / or executable components and / or instructions that, when executed by processor 106 (e.g., a classical processor, a quantum processor, etc.), can facilitate performance of operations defined by the executable components and / or instructions. For example, memory 104 may store computer- and / or machine-readable, writable, and / or executable components and / or instructions that, when executed by processor 106, can facilitate performance of various functions described herein with respect to synthetic fault generation system 102, generator component 108, fault assembler component 110, or another component associated with synthetic fault generation system 102 (e.g., model trainer component 202, aggregator component 204, etc.), or combinations thereof, described herein with or without reference to various figures of this disclosure.

[0027] The memory 104 may include volatile memory (e.g., random access memory (RAM), static RAM (SRAM), dynamic RAM (DRAM), etc.), or non-volatile memory (e.g., read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), etc.), or a combination thereof, that may utilize one or more memory architectures. Further examples of memory 104 are described below with reference to system memory 816 and FIG. 8. Such examples of memory 104 may be utilized to implement any embodiment of the present disclosure.

[0028] The processor 106 may include one or more types of processors or electronic circuitry (e.g., classical processors, quantum processors, etc.) that can implement one or more computer- and / or machine-readable, writable, and / or executable components or instructions that can be stored in the memory 104. For example, the processor 106 may perform various operations that can be specified by such computer- and / or machine-readable, writable, and / or executable components or instructions, including, but not limited to, logic, control, input / output (I / O), arithmetic, or the like, or a combination thereof. In some embodiments, the processor 106 may include one or more central processing units, multi-core processors, microprocessors, dual microprocessors, microcontrollers, systems-on-chips (SOCs), array processors, vector processors, quantum processors, or another type of processor, or a combination thereof. Further examples of the processor 106 are described below with reference to the processing unit 814 and FIG. 8. Such examples of the processor 106 may be utilized to implement any embodiment of the present disclosure.

[0029] The synthetic fault generation system 102, memory 104, processor 106, generator component 108, fault assembler component 110, or other components of the synthetic fault generation system 102 described herein (e.g., model trainer component 202, aggregator component 204, etc.), or combinations thereof, may be communicatively, electrically, operatively, and / or optically coupled to each other via a bus 112 to perform the functions of the system 100, the synthetic fault generation system 102, or any components or combinations thereof coupled thereto. The bus 112 may include one or more memory buses, memory controllers, peripheral buses, external buses, local buses, quantum buses, or other types of buses or combinations thereof, which may utilize various bus architectures. Further examples of the bus 112 are described below with reference to the system bus 818 and FIG. 8. Such examples of the bus 112 may be utilized to implement any embodiment of the present disclosure.

[0030] The synthetic fault generation system 102 may include any type of component, machine, device, facility, equipment, and / or instrument, including a processor, and / or may be capable of effective and / or operative communication with a wired and / or wireless network. All such embodiments are contemplated. For example, the synthetic fault generation system 102 may include a server device, a computing device, a general-purpose computer, an application-specific computer, a quantum computing device (e.g., a quantum computer), a tablet computing device, a handheld device, a server-class computing machine and / or database, a laptop computer, a notebook computer, a desktop computer, a mobile phone, a smartphone, a consumer electronics and / or instrumentation, an industrial and / or commercial device, a digital assistant, a multimedia Internet-enabled telephone, a multimedia player, or another type of device, or a combination thereof.

[0031] The synthetic impairment generation system 102 may be communicatively coupled (e.g., communicatively, electrically, operatively, optically, etc.) to one or more external systems, sources, or devices (e.g., classical and / or quantum computing devices, communication devices, etc.), or combinations thereof, using wires or cables or both. For example, the synthetic impairment generation system 102 may be communicatively coupled (e.g., communicatively, electrically, operatively, optically, etc.) to one or more external systems, sources, or devices (e.g., classical and / or quantum computing devices, communication devices, etc.), or combinations thereof, using data cables, including, but not limited to, High-Definition Multimedia Interface (HDMI) cables, Recommendation Standard (RS) 232 cables, Ethernet cables, or other data cables, or combinations thereof.

[0032] In some embodiments, the synthetic fault generation system 102 may be coupled (e.g., communicatively, electrically, operatively, optically, etc.) to one or more external systems, sources, or devices (e.g., classical and / or quantum computing devices, communication devices, etc.), or combinations thereof, via a network. For example, such networks may include wired and / or wireless networks, including, but not limited to, a cellular network, a wide area network (WAN) (e.g., the Internet), or a local area network (LAN). The synthetic impairment generation system 102 may be used to generate synthetic impairments for a wide variety of networks, including, but not limited to, Wireless Fidelity (Wi-Fi), Global System for Mobile Communications (GSM), Universal Mobile Telecommunications System (UMTS), Worldwide Interoperability for Microwave Access (WiMAX), Enhanced General Packet Radio Service (Enhanced GPRS), Third Generation Partnership Project (3GPP) Long Term Evolution (LTE), Third Generation Partnership Project 2 (3GPP2) Ultra Mobile Broadcast (UMB), High Speed Packet Access (HSPA), Zigbee, and other networks. It may communicate with one or more external systems, sources, or devices, or combinations thereof, such as computing devices, using virtually any desired wired and / or wireless technology, including 802.XX wireless or legacy telecommunications technologies, or combinations thereof, BLUETOOTH®, Session Initiation Protocol (SIP), ZIGBEE®, RF4CE protocol, WirelessHART protocol, 6LoWPAN (IPv6 over Low Power Wireless Area Network), Z-Wave, ANT, Ultra-Wideband (UWB) standard protocols, and / or other proprietary and non-proprietary communication protocols.Thus, in some embodiments, the synthetic fault generation system 102 may include hardware (e.g., a central processing unit (CPU), a transceiver, a decoder, quantum hardware, a quantum processor, etc.), software (e.g., a set of threads, a set of processes, running software, a quantum pulse schedule, a quantum circuit, a quantum gate, etc.), or a combination of hardware and software that can facilitate communication of information between the synthetic fault generation system 102 and an external system, source, or device (e.g., a computing device, a communication device, etc.), or a combination thereof.

[0033] Synthetic fault generation system 102 may include one or more computer- and / or machine-readable, writable, and / or executable components or instructions, or combinations thereof, which, when executed by processor 106 (e.g., a classical processor, a quantum processor, etc.), may facilitate performance of operations defined by such components and / or instructions. Furthermore, in many embodiments, any component associated with synthetic fault generation system 102 described herein, with or without reference to the various figures of this disclosure, may include one or more computer- and / or machine-readable, writable, and / or executable components and / or instructions, which, when executed by processor 106, may facilitate performance of operations defined by such components and / or instructions. For example, as disclosed herein, the generator component 108, the fault assembler component 110, or any other component associated with the synthetic fault generation system 102 (e.g., the model trainer component 202, the aggregator component 204, etc.), or a combination thereof, may include such computer- and / or machine-readable, writable, and / or executable components and / or instructions. As a result, according to many embodiments, the synthetic fault generation system 102, or any components associated therewith, as disclosed herein, may utilize the processor 106 to execute such computer- and / or machine-readable, writable, and / or executable components and / or instructions to facilitate the performance of one or more operations described herein with reference to the synthetic fault generation system 102, or any such components associated therewith.

[0034] The synthetic fault generation system 102 may facilitate (e.g., via the processor 106) the performance of operations performed by and / or associated with the generator component 108, the fault assembler component 110, or another component associated with the synthetic fault generation system 102 as disclosed herein (e.g., the model trainer component 202, the aggregator component 204, etc.), or a combination thereof. For example, as described in detail below, the synthetic fault generation system 102 may facilitate (e.g., via the processor 106) utilizing trained artificial intelligence (AI) models to generate synthetic system faults represented as combinations of discrete and continuous parameters that define system states, or to analyze the synthetic system faults and generate textual content corresponding to the synthetic system faults, or both.

[0035] In another example, as described in detail below, the synthetic fault generation system 102 may further facilitate (e.g., via the processor 106) preprocessing historical system data, which may include at least one of historical discrete parameters or historical continuous parameters (wherein the historical discrete parameters are represented as one-hot coded vectors, and for the historical continuous parameters, mode-specific normalization with a variational Gaussian mixture model is utilized), training an AI model using a generative adversarial network architecture, training an AI model using a conditional tabular adversarial network, training an AI model using a Wasserstein gradient penalty loss (WGAN-GP Loss), recovering a complex multimodal distribution of at least a subset of the discrete or continuous parameters conditioned on rows of an associated dataset, or generating a knowledge base of the generated synthetic system faults and respective text data, or a combination thereof. In the above example, the text content may include at least one of a system log or a description of the synthetic system fault.

[0036] The generator component 108 may utilize a trained artificial intelligence (AI) model to generate synthetic system faults represented as combinations of discrete and continuous parameters that together define a system state. For example, the generator component 108 may utilize a trained generative adversarial network architecture, such as a trained generative adversarial network (GAN), to generate synthetic system faults represented as combinations of discrete and continuous parameters that together define a system state. In another example, the generator component 108 may utilize a trained conditional tabular adversarial network, such as a trained conditional tabular generative adversarial network (CTGAN), to generate synthetic system faults represented as combinations of discrete and continuous parameters that together define a system state. In the above example, such an AI model that may be utilized by the generator component 108 to generate such synthetic system faults may be trained by a model trainer component 202 as described below with reference to the example embodiment shown in FIG. 2.

[0037] The generator component 108 may utilize such a trained AI model (e.g., a trained CTGAN) to generate various synthetic system faults, each of which may include a particular combination of at least one discrete parameter and at least one continuous parameter that together define the state of a system (e.g., a classical computing software and / or hardware system, a quantum computing software and / or hardware system, etc.). In some embodiments, such at least one discrete parameter or such at least one continuous parameter, or a combination thereof, may be an element and / or a subset of elements in a dataset associated with the system. For example, such at least one discrete and / or continuous parameter may be an element and / or a subset of elements located in a column of such dataset associated with the system, and each row of the dataset may constitute a system fault represented as a combination of at least one such discrete parameter and at least one such continuous parameter. In some embodiments, such at least one discrete and / or continuous parameter may include, but is not limited to, a central processing unit (CPU) parameter, an infrastructure parameter, a memory parameter, or another parameter of a system such as, for example, a software system or a hardware system (e.g., a classical computing software system or hardware system or both, a quantum computing software system or hardware system or both, etc.).

[0038] The generator component 108 may recover a complex multimodal distribution of at least one discrete parameter or a subset of continuous parameters conditioned on the rows of the associated dataset. For example, by utilizing such a trained AI model (e.g., a trained CTGAN) described above to generate synthetic system faults that include particular combinations of at least one discrete parameter or at least one continuous parameter, or both, that together define the state of the system, the generator component 108 may recover a complex multimodal distribution of such combinations of at least one discrete parameter or at least one continuous parameter, or both, conditioned on the rows of the above-described dataset that may be associated with the system.

[0039] The fault assembler component 110 may analyze the synthetic system fault and generate text content corresponding to the synthetic system fault. For example, the fault assembler component 110 may analyze the synthetic system fault, which may be generated by the generator component 108 as described above, and the fault assembler component 110 may further generate text content corresponding to the synthetic system fault, such as, for example, a system log, a description of the synthetic system fault, or other text content, or a combination thereof. In this example, such text content corresponding to the synthetic system fault (e.g., a system log, a description of the synthetic system fault, etc.) may be formatted as a text file or another format, or a combination thereof, that can be read by an entity (e.g., a human, a client, a user, a computing device, a software application, an agent, an ML model, an AI model, etc.) as defined herein.

[0040] In some embodiments, the synthetic fault generation system 102 may be associated with a cloud computing environment. For example, the synthetic fault generation system 102 may be associated with one or more functional abstraction layers (e.g., hardware and software layer 1060, virtualization layer 1070, management layer 1080, or workload layer 1090, or a combination thereof) described below with reference to cloud computing environment 950 or FIG. 10, or a combination thereof.

[0041] The synthetic fault generation system 102 or its components (e.g., generator component 108, fault assembler component 110, model trainer component 202, aggregator component 204, etc.), or a combination thereof, may utilize one or more computing resources of a cloud computing environment 950 described below with reference to FIG. 9, or one or more functional abstraction layers (e.g., quantum software, etc.) described below with reference to FIG. 10, or a combination thereof, to perform one or more operations in accordance with one or more embodiments of the present disclosure described herein. For example, the cloud computing environment 950, or a combination of such one or more functional abstraction layers, may include one or more classical computing devices (e.g., classical computers, classical processors, virtual machines, servers, etc.), quantum hardware, or quantum software (e.g., quantum computing devices, quantum computers, quantum processors, quantum circuit simulation software, superconducting circuits, etc.), or a combination thereof, that may be utilized by the synthetic fault generation system 102 or its components, or a combination thereof, to perform one or more operations in accordance with one or more embodiments of the present disclosure described herein. For example, the synthetic fault generation system 102 or its components or combinations thereof may utilize such one or more classical and / or quantum computing resources to perform one or more classical and / or quantum: arithmetic functions, calculations, and / or equations; computing and / or processing scripts; algorithms; models (e.g., AI models, ML models, etc.); or other operations or combinations thereof according to one or more embodiments of the present disclosure described herein.

[0042] Although this disclosure includes detailed descriptions related to cloud computing, it should be understood that implementation of the teachings recited herein is not limited to cloud computing environments. Rather, embodiments of the present invention can be implemented in connection with any other type of computing environment now known or later developed.

[0043] Cloud computing is a service delivery model for enabling convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processes, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and released with minimal management effort or interaction with the service provider. The cloud model may include at least five characteristics, at least three service models, and at least four deployment models.

[0044] The characteristics are as follows:

[0045] On-Demand Self-Service: Cloud consumers can unilaterally provision computing capacity, such as server time and network storage, automatically as needed, without requiring human interaction with the service provider.

[0046] Broad Network Access: Capabilities are available over the network and accessed through standard mechanisms that facilitate use by heterogeneous thin or thick client platforms (eg, cell phones, laptops, and PDAs).

[0047] Resource Pool: A provider's computing resources are pooled and serve multiple consumers using a multi-tenant model, with different physical and virtual resources dynamically allocated and reallocated according to demand. Although consumers generally have no control or knowledge of the exact location of the resources provided, there is an implication of location independence in that the location may be specifiable at a higher level of abstraction (e.g., country, state, or data center).

[0048] Rapid Elasticity: Capacity can be rapidly and elastically provisioned, in some cases automatically, for rapid scale out, and rapidly released for rapid scale in. To the consumer, the capacity available for provisioning often appears unlimited, and can be purchased in any amount at any time.

[0049] Measured Services: Cloud systems automatically control and optimize resource usage by leveraging measurement capabilities at some level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, and reported, providing transparency to both providers and consumers of utilized services.

[0050] The service model is as follows:

[0051] Software as a Service (SaaS): The consumer is offered the ability to use a provider's applications running on a cloud infrastructure. The applications are accessible from a variety of client devices through a thin-client interface such as a web browser (e.g., web-based email). The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or even individual application capabilities, with the possible exception of limited user-specific application configuration settings.

[0052] Platform as a Service (PaaS): The ability offered to consumers is to deploy applications they create or acquire, formed using programming languages and tools supported by the provider, onto a cloud infrastructure. The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, or storage, but does have control over the deployed applications and, in some cases, the application hosting environment configuration.

[0053] Infrastructure as a Service (IaaS): The ability offered to consumers is to provision processing, storage, network, and other basic computing resources onto which the consumer can deploy and run any software, which may include operating systems and applications. The consumer does not manage or control the underlying cloud infrastructure, but does have control over the operating systems, storage, deployed applications, and, in some cases, limited control of selected network components (e.g., host firewalls).

[0054] The deployment model is as follows:

[0055] Private Cloud: Cloud infrastructure is operated solely for the organization. It can be managed by the organization or a third party and can be on-site or off-site.

[0056] Community Cloud: Cloud infrastructure is shared by multiple organizations and supports a specific community with shared interests (e.g., roles, security requirements, policies, and compliance considerations). It may be managed by the organization or a third party and may reside on-premises or off-premises.

[0057] Public Cloud: Cloud infrastructure is made available to the general public or large industry groups and is owned by organizations that sell cloud services.

[0058] Hybrid Cloud: A combination of two or more clouds (private, community, or public) that remain distinct entities but are joined together by standardized or proprietary technologies (e.g., cloud bursting for load balancing between clouds) that enable data and application portability.

[0059] A cloud computing environment is a service oriented environment that is stateless, low-coupling, modular, and emphasizes semantic interoperability. At its core, cloud computing lies an infrastructure that includes a network of interconnected nodes.

[0060] 2 illustrates a block diagram of an example non-limiting system 200 that can facilitate synthetic system fault generation according to one or more embodiments described herein. The system 200 may comprise a synthetic fault generation system 102, which may further include a model trainer component 202 or an aggregator component 204, or a combination thereof. Repeated descriptions of similar elements or processes, or combinations thereof, utilized in each embodiment are omitted for the sake of brevity.

[0061] The model trainer component 202 may train an AI model using a generative adversarial network architecture. For example, the model trainer component 202 may train an AI model that may be utilized by the generator component 108 to generate synthetic system faults represented as combinations of discrete and continuous parameters that define system states as described above with reference to the example embodiment shown in FIG. 1. For example, the model trainer component 202 may train a generative adversarial network (GAN) that may be utilized by the generator component 108 as described above with reference to FIG. 1, and the model trainer component 202 may train such a GAN using a generative adversarial network architecture. In this example, such a GAN may include a conditional tabular generative adversarial network (CTGAN), and the model trainer component 202 may train such a CTGAN using a generative adversarial network architecture. That is, in this example, the model trainer component 202 may train the CTGAN using a generative adversarial network architecture. Here, one element may define a system fault as a particular combination of at least one discrete parameter and at least one continuous parameter in a dataset, and another element may analyze the defined system fault and provide reasons why, for a particular system, the defined system fault does not represent a legitimate system fault (e.g., a logical system fault) or a meaningful system fault (e.g., a system fault that actually occurs), or a combination thereof.

[0062] To train such a CTGAN, as described above, model trainer component 202 may use historical system data as training data. For example, model trainer component 202 may train such a CTGAN, as described above, using historical system data corresponding to one or more real system faults that occurred in one or more systems, or in such one or more systems, or a combination thereof. In some embodiments, such historical system data may be stored in a database, such as memory 104, and model trainer component 202 may retrieve such historical system data using processor 106.

[0063] In the example embodiment shown in FIG. 2 , such historical system data may include historical system failure data. For example, such historical system data may include historical system failure data that may constitute, define, describe, and / or correspond to one or more real system failures that have occurred in the system. In this example, such historical system failure data may include, but is not limited to, various combinations of historical discrete parameters and historical continuous parameters defining the state of the system (each combination constituting a real system failure that has occurred in the system); historical text data (e.g., historical system logs, historical descriptions of real system failures, etc.) corresponding to real system failures that have occurred in one or more systems; historical fault localization data corresponding to one or more systems; historical root cause data corresponding to one or more systems; historical work order requests corresponding to one or more systems; historical information technology (IT) tickets corresponding to one or more systems; and / or other historical data that may constitute, define, describe, and / or correspond to one or more actual system failures that have occurred in one or more systems.

[0064] To train such a CTGAN, as described above, using the historical system fault data defined above, the model trainer component 202 may preprocess such historical system fault data using the processor 106. For example, the model trainer component 202 may use the processor 106 to preprocess such historical system fault data defined above by representing the historical discrete parameters as one-hot coded vectors and preprocessing the historical continuous parameters using mode-specific normalization with a variational Gaussian mixture model.

[0065] 2, based on the preprocessing of the historical system fault data defined above, the model trainer component 202 may use the preprocessed historical system fault data to train a CTGAN as described above. For example, the model trainer component 202 may use the preprocessed historical system fault data to train (e.g., via processor 106) a CTGAN to generate synthetic system faults represented as combinations of discrete and continuous parameters that define system states. In this example, the model trainer component 202 may train (e.g., via processor 106) a CTGAN with Wasserstein Gradient Penalized Loss (WGAN-GP Loss).

[0066] In some embodiments, the model trainer component 202 may train such a CTGAN as described above, and the model architecture of such a CTGAN and the discriminator associated with such a CTGAN may be defined as follows:

[0067] Model Architecture

number

[0068] where h i (h0,h1,h2) indicates the hidden layer, and α idenotes the scalar value generated by tanh, and β i denotes the mode indicator value generated by gumbel softmax, and d i indicates the discrete values generated by gumbel softmax, cond indicates a vector indicating conditions, ReLU indicates an activation function, BN indicates batch normalization, and FC indicates the application of a linear transformation.

[0069] Discriminator Architecture

number

[0070] where r i￢ (r1,r 10 etc.) indicates row I, drop indicates hidden layer dropout, and C indicates a critic with PAC size 10.

[0071] In some embodiments, the model trainer component 202 may train a CTGAN as illustrated by the diagram 500 described below and illustrated in FIG. 5.

[0072] The aggregator component 204 may generate a knowledge base (not shown) of the generated synthetic system faults and their respective text data. For example, the aggregator component 204 may generate (e.g., using a knowledge base builder application or software) a knowledge base of the generated synthetic system faults, which may be generated by the generator component 108, where such knowledge base may further include respective text data corresponding to each such synthetic system fault, which may be generated by the fault assembler component 110. In an embodiment, the aggregator component 204 may generate a knowledge base that may include various synthetic system faults, which may be generated by the generator component 108 as described above with reference to the example embodiment shown in FIG. 1, and the corresponding respective text data, which may be generated by the fault assembler component 110 as described above with reference to FIG. 1. In another embodiment, the aggregator component 204 may generate a knowledge base that may include such various synthetic system faults and their corresponding respective text data, or one or more real system faults (e.g., actually occurring system faults, known system faults, or both).

[0073] In some embodiments, the aggregator component 204 may add one or more of such generated synthetic system faults and their corresponding text data to an existing knowledge base. For example, the aggregator component 204 may add (e.g., using a knowledge base builder application or software) one or more of such generated synthetic system faults and their corresponding text data to a knowledge base previously generated by the aggregator component 204. In an embodiment, such an existing knowledge base may include various synthetic system faults that may be generated by the generator component 108 as described above with reference to the example embodiment shown in FIG. 1 and the corresponding respective text data that may be generated by the fault assembler component 110 as described above with reference to FIG. 1. In another embodiment, the existing knowledge base may include such various synthetic system faults and their corresponding respective text data, or one or more real system faults (e.g., actually occurring system faults or known system faults), or a combination thereof.

[0074] It should be appreciated that the above-described knowledge bases or existing knowledge bases, or combinations thereof, that may be generated by the aggregator component 204 (e.g., using a knowledge base builder application or software) may be used to train one or more AI or ML models, or combinations thereof, of an automated fault detection system to discover one or more system faults in a particular system. For example, according to one or more embodiments of the present disclosure, the synthetic fault generation system 102 may generate (e.g., via the generator component 108 and the fault assembler component 110) a significant number of synthetic system faults of sufficient quality that they can be used as training data for training one or more AI or ML models, or combinations thereof, to automatically discover one or more real system faults that include the same attributes (e.g., discrete parameters, continuous parameters, etc.) or functionality, or combinations thereof, as the synthetic system faults generated by the synthetic fault generation system 102.

[0075] It should also be appreciated that the above-described knowledge bases or pre-existing knowledge bases, or combinations thereof, that may be generated by aggregator component 204 (e.g., using a knowledge base builder application or software) may be used to discover one or more system faults in a particular system, where such one or more system faults may include the same attributes (e.g., discrete parameters, continuous parameters, etc.) or functionality, or combinations thereof, as one or more synthetic system faults that may be generated in accordance with one or more embodiments of the present disclosure. For example, the above-described knowledge bases or pre-existing knowledge bases, or combinations thereof, that may be generated by aggregator component 204 may be used by, for example, an operations management entity or an application entity, or combinations thereof, to discover one or more system faults in a particular system, where such one or more system faults may include the same attributes (e.g., discrete parameters, continuous parameters, etc.) or functionality, or combinations thereof, as one or more synthetic system faults of the present disclosure. For example, the knowledge base described above, including one or more synthetic system faults that may be generated in accordance with one or more embodiments of the present disclosure, may enable such operations management entities or application entities, or combinations thereof, to discover one or more unknown and / or previously undiscovered system faults in a particular system. In this example, discovering such one or more unknown and / or previously undiscovered system faults in a particular system using one or more synthetic system faults of the present disclosure may thereby enable such operations management entities or application entities, or combinations thereof, to prevent and / or mitigate potential disruptions, malfunctions, or damage, or combinations thereof, to one or more components of such particular system.

[0076] It should also be appreciated that the above-described knowledge bases or pre-existing knowledge bases, or combinations thereof, that may be generated by aggregator component 204 (e.g., using a knowledge base builder application or software) may be used to implement one or more tests (e.g., fault detection tests, stress tests, performance tests, load tests, security tests, etc.) on a particular system using one or more synthetic system faults in such knowledge bases, which may include the same attributes (e.g., discrete parameters, continuous parameters, etc.) or functionality, or a combination thereof, as one or more system faults that may occur in such a particular system. For example, the above-described knowledge bases, including one or more synthetic system faults, that may be generated in accordance with one or more embodiments of the present disclosure, may be used by, for example, an operations management entity or an application entity, or a combination thereof, to implement one or more tests (e.g., fault detection tests, stress tests, performance tests, load tests, security tests, etc.) on a particular system using the one or more synthetic system faults in such knowledge bases, which may include the same attributes (e.g., discrete parameters, continuous parameters, etc.) or functionality, or a combination thereof, as one or more system faults that may occur in such a particular system. In this example, testing a particular system using one or more synthetic system faults of the present disclosure may enable such operations management entity or application entity, or a combination thereof, to prevent and / or mitigate potential disruptions, malfunctions, or damage, or a combination thereof, to one or more components of such particular system.

[0077] 3 illustrates a flow diagram of a non-limiting example computer-implemented method 300 that can facilitate synthetic system fault generation according to one or more embodiments described herein. Repeated descriptions of similar elements or processes or combinations thereof utilized in each embodiment are omitted for the sake of brevity.

[0078] At 302, the computer-implemented method 300 may comprise using a processor (e.g., processor 106) to obtain historical system fault data (e.g., via synthetic fault generation system 102 or model trainer component 202, or a combination thereof). For example, model trainer component 202 may use processor 106 to obtain the historical system fault data, which may be stored in a database, such as memory 104. In this example, such historical system fault data may include the historical system data defined above with reference to the example embodiment illustrated in FIG. 2.

[0079] At 304, the computer-implemented method 300 may comprise using a processor (e.g., processor 106) to preprocess historical system fault data (e.g., via synthetic fault generation system 102 or model trainer component 202, or a combination thereof). For example, as described above with reference to the example embodiment shown in FIG. 2, the model trainer component 202 may use the processor 106 to preprocess such historical system fault data as defined above, which may be obtained at 302 as described above. For example, the model trainer component 202 may preprocess such historical system fault data as defined above by representing the historical discrete parameters as one-hot coded vectors and preprocessing the historical continuous parameters using mode-specific normalization with a variational Gaussian mixture model.

[0080] At 306, the computer-implemented method 300 may include training a model (e.g., via the synthetic fault generation system 102 or the model trainer component 202, or a combination thereof) using a processor (e.g., processor 106). For example, as described above with reference to the example embodiment shown in FIG. 2, the model trainer component 202 may use the processor 106 to train an AI model (e.g., a CTGAN) using preprocessed historical system fault data, which may be preprocessed at 304 as described above. For example, as described above with reference to the example embodiment shown in FIGS. 1 and 2, the model trainer component 202 may use such preprocessed historical system fault data to train an AI model (e.g., a CTGAN) to generate synthetic system faults represented as a combination of discrete and continuous parameters that define system states. In this example, as described above with reference to FIG. 2, the model trainer component 202 may train an AI model (e.g., a CTGAN) with Wasserstein Gradient Penalized Loss (WGAN-GP Loss).

[0081] 4 illustrates a block diagram of a non-limiting example system 400 that can facilitate synthetic system fault generation according to one or more embodiments described herein. Repeated descriptions of similar elements or processes or combinations thereof utilized in each embodiment are omitted for the sake of brevity.

[0082] 4, system 400 may include a generator component 108 or a fault assembler component 110, or a combination thereof, of synthetic fault generation system 102. In this example embodiment, synthetic fault generation system 102 or a generator component 108, or a combination thereof, may receive a synthetic system fault request 402 and create one or more synthetic system faults (e.g., N synthetic system faults). For example, in some embodiments, synthetic fault generation system 102 may include an interface component (not shown), which may include, but is not limited to, an application programming interface (API), a representational state transfer (REST) API, a graphical user interface (GUI), or another interface component that may enable communication or data exchange, or a combination thereof, between an entity or combination thereof defined herein and synthetic fault generation system 102 or one or more of its components or a combination thereof. In this example, such an entity as defined herein (e.g., a human, a client, a user, a computing device, a software application, an agent, an ML model, an AI model, etc.) may use such an interface component of the synthetic fault generation system 102 to submit a synthetic system fault request 402 to the generator component 108.

[0083] In the example embodiment illustrated in FIG. 4 , based on receiving the synthetic system fault request 402 described above, the generator component 108 may generate N synthetic system faults, e.g., utilizing a trained CTGAN, where each of such N synthetic system faults is represented as a combination of at least one discrete parameter and at least one continuous parameter that define a system state. In this example embodiment, the generator component 108 may provide each of such N generated synthetic system faults to the fault assembler component 110. In this example embodiment, the fault assembler component 110 may analyze each of such N synthetic system faults generated by the generator component 108 to determine whether they are normal or significant system faults, or a combination thereof, with respect to a particular system, such as system 404. For example, the fault assembler component 110 may analyze each of such N synthetic system faults generated by the generator component 108 to determine whether they are normal or significant system faults, or a combination thereof, with respect to the particular system, such as system 404.

[0084] In the example embodiment shown in FIG. 4 , system 404 may include a software system or a hardware system, or a combination thereof (e.g., a classical computing software system and / or hardware system, a quantum computing software system and / or hardware system, etc.). In some embodiments, system 404 may serve as a representative system (e.g., a benchmark system) that fault assembler component 110 may use as a standard to analyze each of such N synthetic system faults generated by generator component 108 to determine whether they are normal or significant or a combination thereof with respect to such representative system. In some embodiments, system 404 may include a particular system for which an ML or AI model (e.g., a CTGAN) or a combination thereof may be trained to detect one or more system faults using as training data such N synthetic system faults that may be generated by generator component 108 described above. In these embodiments, fault assembler component 110 may analyze each of such N synthetic system faults generated by generator component 108 to determine whether they are normal or significant or a combination thereof with respect to such particular system.

[0085] To facilitate such analysis of the N synthetic system faults that may be generated by the generator component 108 described above, the fault assembler component 110 may analyze each discrete parameter and each continuous parameter in each of such N synthetic system faults with respect to the system 404. For example, the fault assembler component 110 may evaluate data corresponding to the system 404 or one or more components (e.g., software components, hardware components, etc.), or a combination thereof, to determine whether each of such N synthetic system faults is a legitimate system fault (e.g., a logical system fault) or a significant system fault (e.g., a plausible system fault), or a combination thereof, with respect to the system 404 or one or more components thereof. In this example, such data corresponding to the system 404 or one or more components thereof, or a combination thereof, may include, but is not limited to, specifications, data sheets, protocol data, infrastructure data, functionality data, and / or other data corresponding to the system 404 and / or one or more components thereof (e.g., software components, hardware components, etc.). In this example, the fault assembler component 110 may evaluate such data corresponding to the system 404 or one or more components thereof (e.g., software components, hardware components, etc.) or combinations thereof to determine whether each of such N composite system faults is logical (e.g., makes sense from a technical perspective) and / or whether each of such N composite system faults could actually occur in the system 404.

[0086] 4 , based on a determination by fault assembler component 110 that one or more of the N synthetic system faults that may be generated by generator component 108 with respect to system 404 or one or more components thereof, or a combination thereof, are legitimate system faults (e.g., logical system faults) or significant system faults (e.g., plausible system faults), or a combination thereof, fault assembler component 110 may further generate text content corresponding to each of such one or more N synthetic system faults that fault assembler component 110 determines to be legitimate or significant or a combination thereof. For example, fault assembler component 110 may generate text content, such as a system log or a text description, or a combination thereof, corresponding to each of such one or more N synthetic system faults that fault assembler component 110 determines to be legitimate or significant or a combination thereof. In this example, such text content corresponding to a synthetic system fault (e.g., a system log, a description of the synthetic system fault, etc.) may be formatted as a text file or another format or combination that can be read by an entity defined herein (e.g., a human, a client, a user, a computing device, a software application, an agent, an ML model, an AI model, etc.).

[0087] 4, each of the N synthetic system faults that may be generated by generator component 108 may be combined with corresponding text content that may be generated by fault assembler component 110 to produce a synthetic system fault 406, thereby completing the synthetic system fault generation process that may be performed by synthetic fault generation system 102. In some embodiments, each synthetic system fault 406 may be provided to an entity defined herein that implements synthetic fault generation system 102. For example, each synthetic system fault 406 may be provided to such an entity using an interface component (e.g., an API, a REST API, a GUI, etc.) of synthetic fault generation system 102 described above.

[0088] In some embodiments, each synthetic system fault 406 may be used (e.g., by the aggregator component 204) to generate a knowledge base of various system faults (e.g., various synthetic or real system faults) or combinations thereof. For example, each synthetic system fault 406 may be used by the aggregator component 204 described above with reference to the example embodiment shown in FIG. 2 to generate a knowledge base that may include various synthetic or real system faults (e.g., actually occurring or known system faults or combinations thereof).

[0089] In some embodiments, each synthetic system fault 406 may be added (e.g., by aggregator component 204) to an existing knowledge base that includes various system faults (e.g., various synthetic or real system faults, or a combination thereof). For example, aggregator component 204 may add each synthetic system fault 406 to an existing knowledge base previously generated by aggregator component 204 described above with reference to FIG. 2, where such existing knowledge base may include various synthetic or real system faults, or a combination thereof (e.g., actually occurring or known system faults, or a combination thereof).

[0090] 5 illustrates an example of a non-limiting diagram 500 that can facilitate synthetic system fault generation according to one or more embodiments described herein. Repeated descriptions of similar elements or processes or combinations thereof utilized in each embodiment are omitted for the sake of brevity.

[0091] The generator component 108 may recover a complex multimodal distribution of a subset of at least one discrete parameter or at least one continuous parameter, or a combination thereof, conditioned on rows of an associated dataset. Diagram 500 shows a block diagram depiction of an AI model process (e.g., a CTGAN utilized by the generator component 108) that may be executed to facilitate such recovery as described above. As illustrated by diagram 500, in an example, such an AI model process may utilize three basic elements: a conditional vector, a generator loss, and training by sampling. In this example, the conditional vector may specify a selected category, the generator loss may enforce the creation of a mask vector, and the training by sampling may enforce further sampling across the discrete features.

[0092] In the example embodiment illustrated in FIG. 5, a conditional generator (e.g., a conditional vector) may generate a synthetic row conditioned on one of the discrete columns D1 or D2. As shown in the example embodiment illustrated in FIG. 5, one of such discrete columns D1 or D2 (e.g., discrete column D2 shown in FIG. 5) is first selected. In this example embodiment, based on such selection of one of the discrete columns D1 or D2 (e.g., discrete column D2 as shown in FIG. 5), one of the categories (e.g., Category 1 as shown in FIG. 5) is selected from the selected discrete column D1 or D2. In this example embodiment, these elements (e.g., selected discrete column D2 and selected Category 1 as shown in FIG. 5) identify data that may be obtained from the training dataset (e.g., select rows having the selected column and selected category). In this example embodiment, the generator (e.g., a conditional generator, a conditional vector) is a conditional distribution of rows given that particular value in a particular column. In this example embodiment, the generator loss is used to penalize its loss (e.g., generator loss) by adding cross-entropy averaged over all instances of the batch. In this example embodiment, the output (e.g., conditional vector) produced by the conditional generator needs to be evaluated by a critic (e.g., a critic neural network) as illustrated in diagram 500. In the example embodiment shown in FIG. 5, the critic (e.g., a critic neural network) estimates the distance between the learned conditional distribution of the produced data and the conditional distribution of the actual data. In this example embodiment, the critic (e.g., a critic neural network) uses system performance measurements (e.g., AI model scores) to adjust itself online (e.g., during operation, at run time).

[0093] 6 illustrates a flow diagram of a non-limiting example computer-implemented method 600 that can facilitate synthetic system fault generation according to one or more embodiments described herein. Repeated descriptions of similar elements or processes or combinations thereof utilized in each embodiment are omitted for the sake of brevity.

[0094] At 602, the computer-implemented method 600 may include using a processor (e.g., processor 106) to utilize a trained artificial intelligence (AI) model (e.g., a trained CTGAN) (e.g., via the synthetic fault generation system 102 or the generator component 108, or a combination thereof) to generate a synthetic system fault (e.g., the synthetic system fault 406) represented as a combination of discrete and continuous parameters that define a system state (e.g., that together define the state of a system, e.g., a software system or a hardware system, or a combination thereof).

[0095] At 604, the computer-implemented method 600 may include using a processor (e.g., processor 106) to analyze the synthetic system fault (e.g., via the synthetic fault generation system 102 or the fault assembler component 110, or a combination thereof), and generating text content (e.g., a system log, a description of the synthetic system fault, etc.) corresponding to the synthetic system fault (e.g., via the synthetic fault generation system 102 or the fault assembler component 110, or a combination thereof).

[0096] 7 illustrates a flow diagram of a non-limiting example computer-implemented method 700 that can facilitate synthetic system fault generation according to one or more embodiments described herein. Repeated descriptions of similar elements or processes or combinations thereof utilized in each embodiment are omitted for the sake of brevity.

[0097] At 702, the computer-implemented method 700 may comprise using a processor (e.g., processor 106) to preprocess (e.g., via synthetic fault generation system 102 or model trainer component 202 or a combination) historical system data including at least one historical discrete parameter or historical continuous parameter, or a combination thereof, where the historical discrete parameters are represented as one-hot coded vectors and for the historical continuous parameters, mode-specific normalization using a variational Gaussian mixture model is utilized (e.g., by model trainer component 202). For example, such historical system failure data may include, but is not limited to, various combinations of historical discrete parameters and historical continuous parameters defining the state of the system (each combination constituting a genuine system failure that occurred in the system); historical text data corresponding to genuine system failures that occurred in one or more systems (e.g., historical system logs, historical descriptions of genuine system failures, etc.); historical failure localization data corresponding to one or more systems; historical root cause data corresponding to one or more systems; historical work order requests corresponding to one or more systems; historical information technology (IT) tickets corresponding to one or more systems; and / or other historical data that may constitute, define, describe, and / or correspond to one or more actual system failures that occurred in the system.

[0098] At 704, the computer-implemented method 700 may include using a processor (e.g., processor 106) to train an artificial intelligence (AI) model (e.g., a CTGAN) using a generative adversarial network architecture (e.g., via the synthetic obstacle generation system 102 or the model trainer component 202, or a combination thereof).

[0099] At 706, the computer-implemented method 700 may include using a processor (e.g., processor 106) to train an AI model (e.g., via the synthetic obstacle generation system 102 or the model trainer component 202, or a combination) using the conditional tabular adversarial network.

[0100] At 708, the computer-implemented method 700 may include using a processor (e.g., processor 106) to train the AI model (e.g., via the synthetic fault generation system 102 or the model trainer component 202, or a combination) using Wasserstein Gradient Penalized Loss (WGAN-GP Loss).

[0101] At 710, the computer-implemented method 700 may include using a processor (e.g., processor 106) to utilize the trained AI model (e.g., the trained CTGAN) (e.g., via the synthetic fault generation system 102 or the generator component 108, or a combination thereof) to generate a synthetic system fault (e.g., the synthetic system fault 406) represented as a combination of discrete and continuous parameters that define a system state (e.g., that together define a state of the system, e.g., a software system or a hardware system, or a combination thereof).

[0102] At 712, the computer-implemented method 700 may comprise using a processor (e.g., processor 106) to recover (e.g., via the synthetic fault generation system 102 or generator component 108, or a combination thereof) a complex multi-modal distribution of at least a subset of discrete or continuous parameters conditioned on rows of an associated dataset (e.g., columns of such dataset include various discrete and continuous parameters, and each row of the dataset constitutes a system fault represented as a combination of at least one such discrete parameter and at least one such continuous parameter).

[0103] At 714, the computer-implemented method 700 may include using a processor (e.g., processor 106) to analyze the synthetic system fault (e.g., via the synthetic fault generation system 102 or the fault assembler component 110, or a combination thereof), and generating text content (e.g., a system log, a description of the synthetic system fault, etc.) corresponding to the synthetic system fault (e.g., via the synthetic fault generation system 102 or the fault assembler component 110, or a combination thereof).

[0104] At 716, the computer-implemented method 700 may include using a processor (e.g., processor 106) to generate a knowledge base of the generated synthetic system faults and respective text data (e.g., via the synthetic fault generation system 102 or the aggregator component 204, or a combination thereof).

[0105] The synthetic fault generation system 102 may be associated with various technologies, for example, the synthetic fault generation system 102 may be associated with ML and / or AI model technology, system fault detection technology, automated system fault detection technology, automated ML and / or AI model system fault detection technology, cloud computing technology, or other technologies or combinations thereof.

[0106] The synthetic fault generation system 102 may provide technical improvements to systems, devices, components, operational steps, or process steps, or combinations thereof, associated with the various technologies identified above. For example, the synthetic fault generation system 102 may generate a knowledge base including one or more synthetic system faults that can be used to discover one or more system faults in a particular system, where such one or more system faults may include the same attributes (e.g., discrete parameters, continuous parameters, etc.) or functionality, or a combination thereof, as such one or more synthetic system faults in such knowledge base. For example, such a knowledge base including one or more synthetic system faults that can be generated by the synthetic fault generation system 102 may enable an operations management entity or an application entity, or a combination thereof, to discover one or more unknown and / or previously undiscovered system faults in a particular system. In these examples, the discovery of such one or more unknown and / or previously undiscovered system faults in a particular system using one or more synthetic system faults of the present disclosure may thereby enable such operations management entity or application entity, or a combination thereof, to prevent and / or mitigate potential disruptions, malfunctions, or damage, or a combination thereof, to one or more components of such particular system.

[0107] The synthetic fault generation system 102 may provide technical improvements to a processing unit associated with the synthetic fault generation system 102. For example, such one or more components of such a particular system described above may include a processor (e.g., a CPU, etc.). In this example, by generating the knowledge base described above that can be used to discover one or more system faults in such a particular system, the synthetic fault generation system 102 may prevent and / or mitigate potential interruptions, malfunctions, and / or damage to such processors of such a particular system.

[0108] A practical application of the synthetic fault generation system 102 may be implemented in an automated fault detection system for discovering one or more system faults in a particular system. Such one or more system faults may include the same attributes (e.g., discrete parameters, continuous parameters, etc.) or functionality, or a combination thereof, as one or more synthetic system faults that may be generated by the synthetic fault generation system 102. For example, a practical application of the synthetic fault generation system 102 may be implemented in an automated fault detection system that utilizes one or more AI or ML models, or a combination thereof, to discover one or more system faults in a particular system. In this example, the synthetic fault generation system 102 may generate a significant number of synthetic system faults of sufficient quality that can be used as training data for training such one or more AI or ML models, or a combination thereof, to automatically discover one or more real system faults in such particular system.

[0109] It should be appreciated that the synthetic fault generation system 102 provides a new approach facilitated by relatively new automated fault detection systems that utilize one or more ML or AI models, or a combination thereof, to discover system faults. For example, the synthetic fault generation system 102 provides a new approach to providing a significant amount of high-quality training data for training such one or more ML or AI models, or a combination thereof, to discover system faults. In another example, the synthetic fault generation system 102 provides a new approach to providing synthetic system faults that can be used by an operations management entity or an application entity, or a combination thereof, to discover one or more previously unknown and / or undiscovered system faults that include, for example, the same attributes (e.g., discrete parameters, continuous parameters, etc.) or functionality, or a combination thereof, as such one or more synthetic system faults.

[0110] The synthetic fault generation system 102 may utilize hardware or software to solve problems that are highly technical in nature, not abstract, and cannot be performed by humans as a set of mental activities. In some embodiments, one or more of the processes described herein may be executed by one or more specialized computers (e.g., specialized processing units, specialized classical computers, specialized quantum computers, etc.) to perform defined tasks related to the various technologies identified above. The synthetic fault generation system 102 or its components or combinations thereof may be utilized to solve new problems that arise through the use of advances in the technologies mentioned above, quantum computing systems, cloud computing systems, computer architectures, or another technology or combinations thereof.

[0111] It should be appreciated that the synthetic fault generation system 102 may utilize various combinations of electrical components, mechanical components, and circuitry that cannot be replicated in or performed by the human mind because the various operations that may be performed by the synthetic fault generation system 102 or its components or combinations described herein are operations that are beyond the capabilities of the human mind. For example, the amount of data processed, the speed at which such data is processed, or the types of data processed by the synthetic fault generation system 102 over a particular period of time may be greater than, faster than, or different from the amount, speed, or types of data that can be processed by the human mind over the same period of time.

[0112] According to various embodiments, the synthetic fault generation system 102 may also be fully operational (e.g., fully powered on, fully running, etc.) for performing one or more other functions while performing the various operations described herein. It should be recognized that such simultaneous multi-operation execution exceeds the capabilities of the human mind. It should also be recognized that the synthetic fault generation system 102 may include information that is impossible to manually obtain by an entity such as a human user. For example, the type, amount, or variety of information included in the synthetic fault generation system 102, generator component 108, fault assembler component 110, model trainer component 202, and / or aggregator component 204 may be more complex than information manually obtained by an entity such as a human user.

[0113] For simplicity of explanation, computer-implemented methods are illustrated and described as a series of actions. It is to be understood and appreciated that the subject innovation is not limited by the actions shown, or the order or combination of actions. For example, actions may occur in various orders and / or simultaneously, along with other actions not shown and described herein. Moreover, not all actions shown may be required to implement a computer-implemented method in accordance with the disclosed subject matter. In addition, those skilled in the art will understand and appreciate that a computer-implemented method can alternatively be represented as a series of interrelated states via a state diagram or events. Additionally, it should be further appreciated that the computer-implemented methods disclosed hereinafter and throughout this specification can be stored on an article of manufacture to facilitate transporting and transferring such computer-implemented methods to a computer. The term article of manufacture, as used herein, is intended to encompass a computer program accessible from any computer-readable device or storage medium.

[0114] To provide a context for various aspects of the disclosed subject matter, Figure 8 and the following discussion are intended to provide a general description of a suitable environment in which various aspects of the disclosed subject matter may be implemented. Figure 8 illustrates a block diagram of an example non-limiting operating environment that may facilitate one or more embodiments described herein. For purposes of brevity, repeated descriptions of similar elements utilized in other embodiments described herein are omitted.

[0115] 8, a suitable operating environment 800 for implementing various aspects of the disclosure may also include a computer 812. The computer 812 may also include a processing unit 814, a system memory 816, and a system bus 818. The system bus 818 couples system components including, but not limited to, the system memory 816 to the processing unit 814. The processing unit 814 may be any of a variety of available processors. Dual microprocessors and other multi-processor architectures may also be utilized as the processing unit 814. The system bus 818 can be any of several types of bus structures, including a memory bus or memory controller, a peripheral bus or external bus, or a local bus, or combinations thereof, using any of a variety of available bus architectures, including, but not limited to, Industry Standard Architecture (ISA), Micro Channel Architecture (MSA), Enhanced ISA (EISA), Intelligent Drive Electronics (IDE), VESA Local Bus (VLB), Peripheral Component Interconnect (PCI), Card Bus, Universal Serial Bus (USB), Advanced Graphics Port (AGP), Firewire (registered trademark) (IEEE 1394), Small Computer System Interface (SCSI).

[0116] The system memory 816 may also include volatile memory 820 and nonvolatile memory 822. A basic input / output system (BIOS), containing the basic routines for transferring information between elements within the computer 812, such as during start-up, is stored in the nonvolatile memory 822. The computer 812 may also include removable and non-removable, volatile and non-volatile computer storage media. FIG. 8 illustrates, for example, disk storage 824. Disk storage 824 may also include devices such as, but not limited to, a magnetic disk drive, a floppy disk drive, a tape drive, a Jaz drive, a Zip drive, an LS-100 drive, a flash memory card, or a memory stick. Disk storage 824 may also include storage media separately from or in combination with other storage media. A removable or non-removable interface, such as interface 826, is typically used to facilitate connection of the disk storage 824 to the system bus 818. FIG. 8 also illustrates software that acts as an intermediary between a user and the basic computer resources described in the preferred operating environment 800. Such software may also include, for example, an operating system 828. Operating system 828 , which can be stored on disk storage 824 , acts to control and allocate resources of the computer 812 .

[0117] System applications 830 leverage the management of resources by operating system 828 through program modules 832 and program data 834, for example, stored either in system memory 816 or on disk storage 824. It should be appreciated that the present disclosure may be implemented with various operating systems or combinations of operating systems. Users enter commands or information into computer 812 through input devices 836. Input devices 836 include, but are not limited to, pointing devices such as a mouse, trackball, stylus, touchpad, keyboard, microphone, joystick, gamepad, satellite dish, scanner, television tuner card, digital camera, digital video camera, and webcam. These and other input devices connect to processing unit 814 through system bus 818 via interface ports 838. Interface ports 838 include, for example, serial ports, parallel ports, game ports, and universal serial bus (USB). Output devices 840 use several of the same types of ports as input devices 836. Thus, for example, a USB port may be used to provide input to computer 812 and to output information from computer 812 to output device 840. Output adapter 842 is provided to illustrate that there are some output devices 840, such as monitors, speakers, and printers, among other output devices 840, that require special adapters. Output adapters 842 include, by way of example and not limitation, video and sound cards that provide a means of connection between output device 840 and system bus 818. It should be noted that other devices or systems of devices, or combinations thereof, provide both input and output capabilities, such as remote computer(s) 844.

[0118] The computer 812 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 844. The remote computer 844 may be a computer, a server, a router, a network PC, a workstation, a microprocessor-based device, a peer device or other common network node, and may typically include many or all of the elements described relative to the computer 812. For purposes of simplicity, only a memory storage device 846 is shown with the remote computer 844. The remote computer 844 is logically connected to the computer 812 through a network interface 848 and, in turn, physically connected via a communication connection 850. The network interface 848 encompasses wired and / or wireless communication networks such as a local area network (LAN), a wide area network (WAN), a cellular network, etc. LAN technologies include Fiber Distributed Data Interface (FDDI), Copper Distributed Data Interface (CDDI), Ethernet, Token Ring, etc. WAN technologies include, but are not limited to, point-to-point links, circuit-switched networks such as Integrated Services Digital Networks (ISDN) and variations thereon, packet-switched networks, and Digital Subscriber Lines (DSL). Communications connection(s) 850 refer to the hardware / software utilized to connect network interface 848 to system bus 818. For clarity of illustration, communications connection(s) 850 are shown internal to computer 812, but could also be external to computer 812. The hardware / software for connecting to network interface 848 could also include, by way of example only, internal and external technologies such as ordinary telephone-grade modems, cable modems, modems including DSL modems, ISDN adapters, Ethernet cards, etc.

[0119] Referring now to FIG. 9 , an exemplary cloud computing environment 950 is illustrated. As shown, the cloud computing environment 950 comprises one or more cloud computing nodes 910 with which local computing devices used by cloud consumers, such as a personal digital assistant (PDA) or cellular phone 954A, a desktop computer 954B, a laptop computer 954C, or an automobile computer system 954N, or any combination thereof, may communicate. Although not shown in FIG. 9 , the cloud computing nodes 910 may further include a quantum platform (e.g., a quantum computer, quantum hardware, quantum software, etc.) with which the local computing devices used by the cloud consumers may communicate. The nodes 910 may communicate with each other. The nodes may be physically or virtually grouped (not shown) in one or more networks, such as a private cloud, a community cloud, a public cloud, or a hybrid cloud, or any combination thereof, as described above. This enables the cloud computing environment 950 to provide infrastructure as a service, platform as a service, or software as a service, or any combination thereof, without the need for cloud consumers to maintain resources on their local computing devices. It should be understood that the types of computing devices 954A-N illustrated in FIG. 9 are intended to be exemplary only, and that the computing node 910 and cloud computing environment 950 can communicate with any type of computerized device through any type of network or network-addressable connection (e.g., using a web browser) or both.

[0120] 10, a set of functional abstraction layers provided by cloud computing environment 950 (FIG. 9) is shown. It should be understood in advance that the components, layers, and functions shown in FIG. 10 are intended to be illustrative only, and that embodiments of the invention are not limited thereto. As shown, the following layers and corresponding functions are provided:

[0121] Hardware and software layer 1060 includes hardware and software components. Examples of hardware components include mainframe 1061, RISC (minimum instruction set computer) architecture-based servers 1062, servers 1063, blade servers 1064, storage devices 1065, and networks and network components 1066. In some embodiments, software components include network application server software 1067, database software 1068, quantum platform routing software (not shown in FIG. 10), or quantum software (not shown in FIG. 10), or a combination thereof.

[0122] The virtualization layer 1070 provides an abstraction layer from which the following example virtual entities can be provided: virtual servers 1071, virtual storage 1072, virtual networks including virtual private networks 1073, virtual applications and operating systems 1074, and virtual clients 1075.

[0123] In one example, management layer 1080 may provide the functions described below. Resource provisioning 1081 provides dynamic procurement of computing resources and other resources utilized to perform tasks within the cloud computing environment. Metering and pricing 1082 provides cost tracking as resources are used within the cloud computing environment and charging or billing for the consumption of these resources. In one example, these resources may include application software licenses. Security provides identity verification of cloud consumers and protection for tasks, data, and other resources. User portal 1083 provides access to the cloud computing environment for consumers and system administrators. Service level management 1084 provides cloud computing resource allocation and management to ensure required service levels are met. Service level agreement (SLA) planning and fulfillment 1085 provides advance arrangements and procurement for cloud computing resources that anticipate future requirements according to SLAs.

[0124] The workload layer 1090 provides examples of functionality for which a cloud computing environment may be utilized. Non-limiting examples of workloads and functions that may be provided from this layer include mapping and navigation 1091, software development and lifecycle management 1092, virtual classroom instructional delivery 1093, data analytics processing 1094, transaction processing 1095, and synthetic system fault generation software 1096.

[0125] The present invention may be a system, method, apparatus, or computer program product, or combinations thereof, at any possible level of technical detail of integration. A computer program product may include a computer-readable storage medium (or multiple media) having computer-readable program instructions for causing a processor to execute aspects of the present invention. A computer-readable storage medium may be a tangible device capable of holding and storing instructions for use by an instruction-execution device. A computer-readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the above. A non-exhaustive list of more specific examples of computer-readable storage media may also include portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanically encoded devices such as punch cards or raised structures in grooves with instructions recorded thereon, and any suitable combination of the above. Computer-readable storage media as used herein should not be construed as transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagated through a waveguide or other transmission medium (e.g., light pulses passing through a fiber optic cable), or electrical signals transmitted over wires.

[0126] The computer-readable program instructions described herein may be downloaded to each computing / processing device from a computer-readable storage medium or to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network may include copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium within the respective computing / processing device. The computer-readable program instructions for carrying out operations of the present invention may be either 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®, C++, or the like, conventional procedural programming languages such as the C programming language, or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer, as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be to an external computer (e.g., through the Internet using an Internet Service Provider).In some embodiments, to carry out aspects of the present invention, electronic circuitry including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA), may execute computer-readable program instructions by utilizing state information of the computer-readable program instructions to personalize the electronic circuitry.

[0127] Aspects of the present invention are described herein with reference to flowchart illustrations or block diagrams, or combinations thereof, of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each block of the flowchart illustrations or block diagrams, or combinations thereof, and combinations of blocks in the flowchart illustrations or block diagrams, or combinations thereof, can be implemented by computer-readable program instructions. These computer-readable program instructions may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to create a machine. The instructions, executed by the processor of the computer or other programmable data processing apparatus, thereby form means for implementing the function / acts specified in a block or blocks of the flowchart illustrations or block diagrams, or combinations thereof. These computer-readable program instructions may also be stored on a computer-readable storage medium that can instruct a computer, programmable data processing apparatus, or other device, or combinations thereof, to function in a particular manner. A computer-readable storage medium having instructions stored thereon thereby includes a product including instructions that implement aspects of the function / acts specified in a block or blocks of the flowchart illustrations or block diagrams, or combinations thereof. Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational acts to be performed on the computer, other programmable apparatus, or other device to create a computer-implemented process, whereby the instructions executing on the computer, other programmable apparatus, or other device implement the function / acts specified in a block or blocks of the flowchart or block diagram, or a combination thereof.

[0128] The flowcharts and block diagrams in the figures 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, including one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions described in the blocks may occur out of the order depicted in the figures. For example, two blocks shown in succession may be executed substantially simultaneously, depending on the functionality involved, or the blocks may be executed in reverse order in some cases. It should also be noted that each block of a block diagram or flowchart diagram, or a combination thereof, and combinations of blocks in block diagrams or flowchart diagrams, or a combination thereof, may be implemented by a special-purpose hardware-based system that performs the specified functions or actions, or may execute a combination of special-purpose hardware and computer instructions.

[0129] Although the subject matter has been described above in the general context of computer-executable instructions for a computer program product executing on a computer and / or multiple computers, those skilled in the art will recognize that the present disclosure may also be implemented in combination with other program modules. Generally, program modules include routines, programs, components, data structures, etc. that perform particular tasks and / or implement particular abstract data types. Moreover, those skilled in the art will recognize that the computer-implemented methods of the present invention may be practiced with other computer system configurations, including single-processor or multiprocessor computer systems, minicomputing devices, mainframe computers, computers, handheld computing devices (e.g., PDAs, phones), microprocessor-based or programmable consumer or industrial electronics, etc. The illustrated aspects may also be practiced in distributed computing environments where tasks are performed by remote processing devices linked through a communications network. However, some, if not all, aspects of the present disclosure may be practiced on stand-alone computers. In a distributed computing environment, program modules may be located in both local and remote memory storage devices. For example, in one or more embodiments, computer-executable components may be executed from memory that may include or consist of one or more distributed memory units. As used herein, the terms "memory" and "memory unit" are interchangeable. Furthermore, one or more embodiments described herein may execute code of computer-executable components in a distributed manner (e.g., multiple processors combining or operating cooperatively to execute code from one or more distributed memory units). As used herein, the term "memory" may encompass a single memory or memory unit in one location, or multiple memories or memory units in one or more locations.

[0130] As used herein, terms such as “component,” “system,” “platform,” and “interface” may refer to and / or include computer-related entities or entities associated with operating machines having one or more specific functionalities. The entities disclosed herein may be hardware, a combination of hardware and software, software, or software in execution. For example, a component may be, but is not limited to, a process running on a processor, a processor, an object, an executable, a thread of execution, a program, or a computer, or a combination thereof. By way of illustration, both an application running on a server and the server may be a component. One or more components may reside within a process and / or thread of execution, and a component may be localized on one computer and / or distributed between two or more computers. In another example, each component may execute from various computer-readable media having various data structures stored thereon. Components may communicate via local and / or remote processes, such as according to signals comprising one or more data packets (e.g., data from one component interacting with another component in a network such as the Internet, a local system, a distributed system, or another system, or a combination thereof, via signals). As another example, a component may be a device having inherent functionality provided by mechanical parts operated by electrical or electronic circuitry that is operated by a software or firmware application executed by a processor. In such cases, the processor may be internal or external to the device and may execute at least a portion of the software or firmware application.As yet another example, a component may be a device that provides its inherent functionality without mechanical parts through electronic components, which may include a processor or other means for executing software or firmware that provides at least a portion of the functionality of the electronic component. In an aspect, a component may emulate an electronic component via, for example, a virtual machine in a cloud computing system.

[0131] Additionally, the term "or" is intended to mean an inclusive "or" rather than an exclusive "or." That is, unless otherwise specified or clear from context, "X utilizes A or B" is intended to mean any of the natural inclusive permutations. That is, if X utilizes A, X utilizes B, or X utilizes both A and B, then "X utilizes A or B" is satisfied under any of the foregoing examples. Furthermore, as used in this specification and the appended claims, the articles "a" and "an" should generally be construed to mean "one or more" unless otherwise specified or clear from context that the singular is intended. As used herein, the terms "example" and / or "exemplary" are used to mean serving as an example, instance, or illustration. For the avoidance of doubt, the subject matter disclosed herein is not limited to such examples. Additionally, any aspect or design described herein as "example" and / or "exemplary" is not necessarily to be construed as preferred or superior over other aspects or designs, nor is it intended to exclude equivalent exemplary structures and techniques known to those skilled in the art.

[0132] The term "processor" as used herein may refer to virtually any computing processing unit or device, including, but not limited to, a single-core processor, a single processor with software multithreading execution capabilities, a multi-core processor, a multi-core processor with software multithreading execution capabilities, a multi-core processor with hardware multithreading technology, a parallel platform, and a parallel platform with distributed shared memory. Additionally, a processor may refer to an integrated circuit, an application-specific integrated circuit (ASIC), a digital signal processor (DSP), a field-programmable gate array (FPGA), a programmable logic controller (PLC), a complex programmable logic device (CPLD), discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. Furthermore, a processor may utilize nanoscale architectures, such as, but not limited to, molecular and quantum dot-based transistors, switches, and gates, to optimize space utilization or enhance the performance of user equipment. A processor may also be implemented as a combination of computing processing units. In this disclosure, terms such as "store," "storage," "data store," "data storage," "database," and substantially any other information storage component associated with the operation and functionality of a component are utilized to refer to a "memory" or a "memory component" entity embodied in a component that includes memory. It should be recognized that memory or memory components or combinations thereof described herein can be either volatile memory or non-volatile memory, or can include both volatile and non-volatile memory.By way of example, and not limitation, non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable ROM (EEPROM), flash memory, or non-volatile random access memory (RAM) (e.g., ferroelectric RAM (FeRAM)). Volatile memory may include RAM, which may act as external cache memory, for example. By way of example, and not limitation, RAM is available in many forms, including synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), Synchlink DRAM (SLDRAM), direct Rambus RAM (DRRAM), direct Rambus dynamic RAM (DRDRAM), and Rambus dynamic RAM (RDRAM). Additionally, the disclosed memory components of systems or computer-implemented methods herein are intended to include, but are not limited to, these and any other suitable types of memory.

[0133] What has been described above includes only example systems and computer-implemented methods. Of course, for purposes of describing this disclosure, it is not possible to describe every conceivable combination of components or computer-implemented methods, but one of ordinary skill in the art will recognize that many further combinations and permutations of the present disclosure are possible. Furthermore, when terms such as "including," "having," and "comprising" are used in the detailed description, claims, appendices, and drawings, such terms are intended to be inclusive in the same manner as the term "comprising" is interpreted when used as a transitional phrase in the claims.

[0134] The description of various embodiments is presented for illustrative purposes and is not intended to be exhaustive or limited 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 terminology used herein was selected to best explain the principles of the embodiments, practical applications, or technical improvements over techniques found in the industry, or to enable those skilled in the art to understand the embodiments disclosed herein. (Other possible items) [Item 1] 1. A system comprising: The following computer-executable components stored on a non-transitory computer-readable medium: a generator component that utilizes a trained artificial intelligence (AI) model to generate synthetic system faults represented as combinations of discrete and continuous parameters that define the system state; and a fault assembler component that analyzes the synthetic system faults and generates textual content corresponding to the synthetic system faults; 2. A system comprising a processor that executes [Item 2] Item 10. The system of item 1, further comprising a model trainer component that trains the AI model using a generative adversarial network architecture. [Item 3] 3. The system of claim 2, wherein the generative adversarial network architecture is a conditional tabular adversarial network. [Item 4] 4. The system of claim 2 or 3, wherein the model trainer component preprocesses historical system data including at least one of historical discrete parameters or historical continuous parameters, wherein the historical discrete parameters are represented as one-hot coded vectors and, for the historical continuous parameters, mode-specific normalization using a variational Gaussian mixture model is utilized. [Item 5] 5. The system of any one of items 2 to 4, wherein the model trainer component trains the AI model using Wasserstein Gradient Penalized Loss (WGAN-GP Loss). [Item 6] 6. The system of any one of items 1 to 5, wherein the generator component recovers a complex multimodal distribution of at least a subset of the discrete parameters or the continuous parameters conditioned on rows of an associated dataset. [Item 7] 7. The system of any one of items 1 to 6, wherein the textual content includes at least one of a system log or a description of the synthetic system failure. [Item 8] 8. The system of any one of items 1 to 7, wherein the computer-executable components further include an aggregator component that generates a knowledge base of generated synthetic system faults and respective text data. [Item 9] using a processor to generate synthetic system faults represented as combinations of discrete and continuous parameters that define system states, utilizing a trained artificial intelligence (AI) model; using the processor to analyze the synthesis system fault and generate text content corresponding to the synthesis system fault; 1. A computer-implemented method comprising: [Item 10] 10. The computer-implemented method of claim 9, further comprising using the processor to train the AI model using a generative adversarial network architecture. [Item 11] 11. The computer-implemented method of claim 9 or 10, further comprising using the processor to train the AI model using a conditional tabular adversarial network. [Item 12] 12. The computer-implemented method of claim 9, further comprising using the processor to preprocess historical system data including at least one of historical discrete parameters or historical continuous parameters, wherein the historical discrete parameters are represented as one-hot coded vectors and, for the historical continuous parameters, mode-specific normalization using a variational Gaussian mixture model is utilized. [Item 13] 13. The computer-implemented method of any one of items 9 to 12, further comprising using the processor to train the AI model using Wasserstein Gradient Penalized Loss (WGAN-GP Loss). [Item 14] 14. The computer-implemented method of any one of items 9 to 13, further comprising using the processor to recover a complex multimodal distribution of at least a subset of the discrete parameters or the continuous parameters conditioned on rows of an associated dataset. [Item 15] 15. The computer-implemented method of any one of claims 9 to 14, further comprising using the processor to generate a knowledge base of generated synthetic system faults and respective text data. [Item 16] 1. A program comprising program instructions executable by a processor, the program instructions causing the processor to: Utilizing a trained artificial intelligence (AI) model to generate synthetic system faults represented as combinations of discrete and continuous parameters that define system states; and analyzing the synthesis system failure and generating text content corresponding to the synthesis system failure; A program that performs the following. [Item 17] Item 17. The program of item 16, wherein the program instructions are further executable by the processor to cause the processor to train the AI model using a generative adversarial network architecture. [Item 18] 18. The program of claim 16 or 17, wherein the program instructions are further executable by the processor to cause the processor to train the AI model using a conditional tabular adversarial network. [Item 19] 19. The program of any one of items 16 to 18, wherein the program instructions are further executable by the processor to cause the processor to preprocess historical system data including at least one of historical discrete parameters or historical continuous parameters, wherein the historical discrete parameters are represented as one-hot coded vectors and mode-specific normalization using a variational Gaussian mixture model is utilized for the historical continuous parameters. [Item 20] 20. The program of claim 16, wherein the program instructions are further executable by the processor to cause the processor to generate a knowledge base of generated synthetic system faults and respective text data.

Claims

1. 1. A system comprising: a processor; The processor executes a program stored on a non-transitory computer-readable medium, a generator component that uses an artificial intelligence (AI) model trained based on a distribution of historical system data including historical discrete parameters and historical continuous parameters that constitute real system faults that have occurred in the system, among the discrete parameters and continuous parameters that define the state of the system, to generate a synthetic system fault that is expressed as a combination of the discrete parameters and the continuous parameters synthesized by the AI model; a fault assembler component that analyzes the synthetic system fault and generates a system log corresponding to the synthetic system fault or text content that includes a description of the synthetic system fault; A system that functions as a

2. The system described in claim 1, wherein the discrete parameters and the continuous parameters include at least one of central processing unit (CPU) parameters, infrastructure parameters, and memory parameters.

3. When the processor executes the program, 3. The system of claim 1 or 2, further functioning as a model trainer component that trains the AI model using a generative adversarial network architecture.

4. The system of claim 3 , wherein the generative adversarial network architecture is a conditional tabular adversarial network.

5. When the processor executes the program, 5. The system of claim 3 or 4, functioning as the model trainer component, for the historical system data including at least one of the historical discrete parameters or the historical continuous parameters, to represent the historical discrete parameters as one-hot coded vectors and preprocess the historical continuous parameters by mode-specific normalization using a variational Gaussian mixture model.

6. When the processor executes the program, 6. The system of claim 3, wherein the model trainer component functions to train the AI model using a Wasserstein Gradient Penalized Loss (WGAN-GP Loss).

7. The historical discrete parameters and the historical continuous parameters are elements and / or subsets of elements located in columns of a dataset associated with the system, and each row of the dataset constitutes a system fault represented as a combination of at least one of the historical discrete parameters and at least one of the historical continuous parameters; When the processor executes the program, 7. The system of claim 3, wherein the generator component generates a conditional distribution of at least a subset of the historical discrete parameters or the historical continuous parameters contained in a row of the dataset given a particular value in a particular column.

8. When the processor executes the program, 8. The system of claim 7, wherein the model trainer component functions to train the AI model by estimating a distance between the conditional distribution generated by the generator component and a conditional distribution of actual data for a row given the particular value in the particular column obtained from the dataset.

9. When the processor executes the program, The system of claim 1 , further functioning as an aggregator component that generates a knowledge base that associates and stores generated synthetic system faults with data on the text content generated by the fault assembler component for the synthetic system faults.

10. A step in which, by executing a program by a processor, the processor uses an artificial intelligence (AI) model trained based on a distribution of historical system data including historical discrete parameters and historical continuous parameters that constitute real system faults that have occurred in the system, among discrete parameters and continuous parameters that define the state of a system including the processor, to generate a synthetic system fault, the synthetic system fault being represented as a combination of the discrete parameters and the continuous parameters; executing the program with the processor, whereby the processor analyzes the synthetic system fault and generates a system log corresponding to the synthetic system fault or text content including a description of the synthetic system fault; 1. A computer-implemented method comprising:

11. The computer-implemented method of claim 10, further comprising a step in which the processor, when executing the program, trains the AI model using a generative adversarial network architecture.

12. The computer-implemented method of claim 10 or 11, further comprising the step of causing the processor to train the AI model using a conditional tabular adversarial network by executing the program.

13. A computer-implemented method according to any one of claims 10 to 12, further comprising the step of: when the processor executes the program, the processor, for the historical system data including at least one of the historical discrete parameters or the historical continuous parameters, represents the historical discrete parameters as one-hot coded vectors and preprocesses the historical continuous parameters by mode-specific normalization using a variational Gaussian mixture model.

14. The computer-implemented method of claim 10, further comprising the step of causing the processor to train the AI model using Wasserstein Gradient Penalized Loss (WGAN-GP Loss) by executing the program.

15. The historical discrete parameters and the historical continuous parameters are elements and / or subsets of elements located in columns of a dataset associated with the system, and each row of the dataset constitutes a system fault represented as a combination of at least one of the historical discrete parameters and at least one of the historical continuous parameters; 15. The computer-implemented method of claim 10, further comprising: causing the processor to execute the program, thereby generating a conditional distribution of at least a subset of the historical discrete parameters or the historical continuous parameters contained in a row of the dataset given a particular value in a particular column.

16. A method implemented by a computer as described in any one of claims 10 to 15, further comprising a step in which the processor, by executing the program, generates a knowledge base in which the processor stores generated synthesis system faults and data on the text content generated for the synthesis system faults in correspondence with each other.

17. A program comprising program instructions, the program instructions being executable by a processor, the program instructions causing the processor to: generating a synthetic system fault represented as a combination of discrete and continuous parameters defining a state of a system including the processor, the synthetic system fault being expressed as a combination of the discrete and continuous parameters; and analyzing the synthetic system fault and generating a system log corresponding to the synthetic system fault or text content including a description of the synthetic system fault; A program that performs the following.

18. 20. The program of claim 17, wherein the program instructions are further executable by the processor to cause the processor to train the AI model using a generative adversarial network architecture.

19. 19. The program of claim 17 or 18, wherein the program instructions are further executable by the processor to cause the processor to train the AI model using a conditional tabular adversarial network.

20. 20. The program of claim 17, wherein the program instructions are further executable by the processor to cause the processor to, for the historical system data including at least one of the historical discrete parameters or the historical continuous parameters, represent the historical discrete parameters as one-hot coded vectors and generate mode-specific normalized conditional distributions for the historical continuous parameters using a variational Gaussian mixture model.

21. 21. The program of claim 17, wherein the program instructions are further executable by the processor to cause the processor to generate a knowledge base that stores generated synthesis system faults and data of the text content generated for the synthesis system faults in association with each other.

Images