Method and device for virtual machine failure prediction based on machine-learning

The machine learning-based method using BERT and CNN models effectively predicts virtual machine failures in SDN and NFV environments by analyzing log data, addressing the complexity and volume challenges, and enabling proactive handling to enhance service availability.

WO2024232470A1PCT designated stage expired Publication Date: 2024-11-14POSTECH ACADEMY INDUSTRY FOUNDATION

Patent Information

Application Number
PCT/KR2023/008760
Authority / Receiving Office
WO · WO
Patent Type
Applications
Current Assignee / Owner
Priority Date
2023-05-09
Filing Date
2023-06-23
Publication Date
2024-11-14

AI Technical Summary

Technical Problem

In software-defined network (SDN) and network function virtualization (NFV) environments, predicting virtual machine failures is challenging due to the complexity of network structures and the large volume of log data, which is often text-based and difficult to analyze automatically, leading to delayed failure detection and potential service availability issues.

Method used

A machine learning-based method using BERT and CNN models to analyze log data from virtual machines, converting text logs into numerical matrices, and predicting failure probabilities, with preprocessing steps to filter relevant logs and fine-tune models for accurate predictions, enabling proactive failure handling such as virtual machine migration.

Benefits of technology

Enables early prediction of virtual machine failures, allowing for proactive measures to be taken, such as migration, thereby reducing downtime and improving service availability in high-availability services like 5G and financial services.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure KR2023008760_14112024_PF_FP_ABST
    Figure KR2023008760_14112024_PF_FP_ABST
Patent Text Reader

Abstract

Disclosed are a method and device for predicting the probability of failure occurrence in virtual machines through log analysis of each server in a software definition network and a network function virtualization environment. This method comprises the steps of: acquiring log data that is a combination of logs generated in each of virtual machines operating virtual network functions or a web server and logs of servers loaded with virtual machines; converting the log data into a log-embedding matrix, which is a numerical matrix representing features of the logs, by inputting the log data to a trained language model; and predicting the probability of failure occurrence in the virtual machines within a certain time period for each of the servers by using a convolutional neural network model that uses the log-embedding matrix as input.
Need to check novelty before this filing date? Find Prior Art

Description

Machine learning-based virtual machine failure prediction method and device

[0001] The present invention relates to a method for predicting failure of a server connected to a network and a virtual machine installed on the server, and more specifically, to a method and device for predicting the probability of failure of a virtual machine through server-specific log analysis in a software-defined network and network function virtualization environment.

[0002] Software-Defined Network (SDN) is a technology that separates the control plane and data plane of network devices, implements complex network control functions as software on general-purpose computers, and controls multiple data planes in a centralized manner.

[0003] Software-defined networks, when combined with Network Function Virtualization (NFV) technology, can reduce operating and investment costs and accelerate the implementation of new features by implementing expensive middlebox equipment as software on virtual servers. This technology is actively being applied in various environments, including 5G core networks and public and private cloud data centers.

[0004] However, the introduction of these SDN and NFV technologies has made network structures more complex, and the introduction of virtualization technologies in networks and servers has made diagnosing and managing network and server failures more difficult. Specifically, in SDN and NFV environments, failures in servers and virtual machines (VMs) that process actual user application services can lead to reduced service availability and customer dissatisfaction if these failures are not promptly addressed.

[0005] Existing network and server management technologies have focused on detecting failures in real time and taking quick follow-up measures. However, in recent services requiring high availability, such as 5G services and financial services, research and development is being conducted toward predicting failures in advance and taking proactive measures, such as server migration, to ensure service quality.

[0006] Most virtual machine failures are due to abnormal conditions in the server running the virtual machine, and therefore, failure symptoms related to server abnormalities can be predicted based on these. Specifically, failure symptoms of servers and virtual machines can be identified by analyzing the various log data generated by the servers and virtual machines. However, the sheer volume of logs generated by virtual machines and servers makes it difficult for network administrators to manually analyze and predict failures on a case-by-case basis. Furthermore, because log data is text data containing linguistic meaning, automated failure analysis also presents challenges.

[0007] The purpose of the present invention to solve the problems of the prior art as described above is to provide a method and device for automatically analyzing logs of virtual machines installed on servers in a network function virtualization environment using machine learning to predict in advance the probability of virtual machine failure for each server.

[0008] Another object of the present invention is to provide a method and device for predicting virtual machine failures for each server, which can effectively detect failures of virtual machines that have not been learned before by analyzing logs of all virtual machines installed on a server using a BERT (Bidirectional Encoder Representations from Transformers) and a Convolution Neural Network (CNN) model.

[0009] According to one aspect of the present invention for solving the above technical problem, a virtual machine failure prediction method used in an environment in which a virtual machine is operated on a server and a virtual network function (VNF) is operated on the virtual machine to provide network functions to a user or client includes the steps of: performing pre-training based on log data tagged with failure status; collecting all logs generated from each virtual machine (VM) and a server that operates VMs; converting the collected logs into a log embedding matrix, which is a numerical matrix representing the characteristics of the logs, by using the input of a BERT (Bidirectional Encoder Representations from Transformers); and predicting the probability of a failure occurring in the VM for each server by using a pre-trained convolutional neural network (CNN) based on the converted matrix.

[0010] The above method may further include a step of preprocessing the collected logs.

[0011] The above method, when using the CNN, may further include a pre-training step of fine-tuning the BERT model and the CNN model using backpropagation of the CNN model and the BERT model.

[0012] The above method may further include a step of determining a failure handling method for a virtual machine predicted to fail within the predetermined time period in the above-described predicting step. The step of determining the failure handling method may include a step of migrating virtual machines from a server predicted to fail to a server predicted to fail. In other words, the above method may further include a virtual machine migration step.

[0013] According to another aspect of the present invention for solving the above technical problem, a method for predicting virtual machine failure includes the steps of: acquiring log data obtained by combining logs generated from each of virtual machines installed on a server operating in a network function virtualization environment and operating a virtual network function or a web server with the logs of the server; using the log data as input to a pre-trained language model to convert it into a log embedding matrix, which is a numerical matrix representing the characteristics of the logs; and using a convolutional neural network model that takes the log embedding matrix as input to predict the probability that a failure will occur in virtual machines for each server within a certain period of time. The log data may include failure-related logs based on the logs of the virtual machines and failure histories of the virtual machines.

[0014] The above language model may be a model that is pre-trained based on log data tagged with a failure status, and outputs different embeddings for the same word by understanding the context of sentences in the log data.

[0015] The above language model may be a model that divides the word into smaller subwords and uses them as tokens to generate an output embedding for each token.

[0016] The above language model may be a model that uses a special token indicating the beginning of a sentence and a position embedding to generate the above output embedding.

[0017] The above language model and the above convolutional neural network model can be fine-tuned through backpropagation during the pre-training process, and can be installed so that the entire hyperparameters of the language model are modified by the fine-tuning.

[0018] The above virtual machine failure prediction method may further include a step of preprocessing the log data before the log data is input to a pre-trained language model.

[0019] When the log of the virtual machine operating the above virtual network function or web server is a kernel log, the preprocessing may include removing the address of the major register of the kernel log based on a preset rule.

[0020] The above preprocessing may include leaving only logs that contain at least one word among the preset words among the logs.

[0021] The above words may include at least some of the following: reset, fail, not, failure, timeout, kill, err, out of memory (oom), stop, exit, restart, long, and warn.

[0022] The above preprocessing may include a process of extracting time information and application information from the logs, a process of removing numbers and symbols from the logs, a process of changing uppercase letters to lowercase letters in the logs, or a combination thereof.

[0023] The above virtual machine failure prediction method may further include a step of chronologically sorting all logs of an input window in which the logs of the server and the logs of the virtual machines are combined based on time information extracted from the logs.

[0024] The above virtual machine failure prediction method may further include a step of combining logs generated from each of the virtual machines and logs generated from the server in a single input window; and a step of combining logs generated from each of the virtual machines and failure histories generated by the results of checking the network connection status for each of the virtual machines into a single failure history.

[0025] The above virtual machine failure prediction method may further include, in the prediction step, a step of determining a failure handling method for a virtual machine having a probability of failure occurring within the predetermined time period. The failure handling method may include transferring virtual machines of a server predicted to fail within the predetermined time period to a server not predicted to fail within the predetermined time period.

[0026] At least some of the above virtual machines may be configured to pass through a plurality of virtual network functions configured as service function chaining to dynamically provide end-to-end services with other servers according to the type of server and traffic identification, and may be configured to perform message procedures for the service function chaining.

[0027] The above virtual machine failure prediction method may further include a step of generating training data for training the convolutional neural network model. The step of generating the training data may include sending a packet or test signal of a certain size to each of the virtual machines, receiving a response message for the packet or test signal, and analyzing the response message to determine the network connection status of each of the virtual machines.

[0028] According to another aspect of the present invention for solving the above technical problem, a virtual machine failure prediction device is provided, which performs a machine learning-based virtual machine failure prediction method, and which includes at least one processor that executes program commands stored in a memory to predict a failure of a virtual machine based on machine learning. The at least one processor may be equipped with a pre-trained language model that converts log data generated from each of virtual machines that are installed in a server operating in a network function virtualization environment and that operates a virtual network function or a web server into a log embedding matrix, which is a numerical matrix representing the characteristics of the log, by using the log data combined with the log of the server as input; and a convolutional neural network model that uses the log embedding matrix as input to predict the probability that a failure will occur in virtual machines for each server within a certain period of time.

[0029] The above log data may include logs of the virtual machines and failure-related logs based on failure histories of the virtual machines.

[0030] The above pre-trained language model may be a model that is pre-trained based on log data tagged with a fault, and then outputs different embeddings for the same word by understanding the context of sentences in the log data.

[0031] The pre-trained language model and the convolutional neural network model can be fine-tuned through backpropagation during the pre-training process. This fine-tuning can modify the entire hyperparameters of the pre-trained language model.

[0032] The virtual machine failure prediction device may further include a preprocessing unit that preprocesses the log data before the log data is input to the pre-trained language model. The preprocessing unit may be configured to remove the address of the major register of the kernel log based on a preset rule when the log of the virtual machine operating the virtual network function or web server is a kernel log. The preprocessing unit may be configured to leave only logs that include at least one word among preset words among the logs. In addition, the preprocessing unit may be configured to perform a process of extracting time information and application information from the logs, a process of removing numbers and symbols from the logs, a process of changing uppercase letters to lowercase letters in the logs, or a combination thereof.

[0033] The above virtual machine failure prediction device may further include a monitoring node that generates the log data. The monitoring node may be configured to merge logs generated from each of the virtual machines and logs generated from the server into a single input window, and to merge logs generated from each of the virtual machines and failure histories of each of the virtual machines, generated based on the results of checking the network connection status of each of the virtual machines, into a single failure history.

[0034] The above monitoring node may be configured to sort all logs of an input window in which the logs of the server and the logs of the virtual machines are combined in chronological order based on time information extracted from the logs.

[0035] The processor may be configured to determine a failure handling method for a virtual machine with a probability of failure within the predetermined time period. The failure handling method may include transferring virtual machines from a server predicted to fail within the predetermined time period to a server predicted not to fail within the predetermined time period.

[0036] The processor may generate training data for training the convolutional neural network model. To generate the training data, the processor may further include a status checker that sends packets or test signals of a certain size to each of the virtual machines, receives response messages for the packets or test signals, and analyzes the response messages to check the network connection status of each of the virtual machines.

[0037] According to the present invention described above, there is an effect of being able to predict failures for each server at least several minutes to several tens of minutes before a failure occurs in a virtual machine, thereby taking measures in advance to prevent failures in the virtual machine.

[0038] In addition, according to the present invention, there is an advantage in that a large amount of log messages generated from servers and virtual machines can be automatically and effectively analyzed through a convolutional neural network that makes judgments without losing input information, together with BERT (Bidirectional Encoder Representations from Transformers) that understands the meaning of sentences and generates word embeddings in the field of natural language processing, thereby quickly identifying and responding to messages related to server or virtual machine errors.

[0039] FIG. 1 is a schematic block diagram illustrating an open stack-based network function virtualization environment of a virtual machine failure prediction system according to one embodiment of the present invention.

[0040] Figure 2 is an exemplary diagram for explaining the process of collecting log data in the virtual machine failure prediction system of Figure 1.

[0041] FIG. 3 is a block diagram illustrating a configuration that can be employed in a monitoring node of the virtual machine failure prediction system of FIG. 1.

[0042] FIG. 4 is an exemplary diagram illustrating a process of tagging failure data for each server in a log data generation process that can be employed in the virtual machine failure prediction system of FIG. 1.

[0043] FIG. 5 is a block diagram illustrating a configuration that can be employed in a BERT (Bidirectional Encoder Representations from Transformers) module within a failure prediction module of the virtual machine failure prediction system of FIG. 1.

[0044] Figure 6 is an example diagram for explaining the structure of a BERT tokenizer and BERT model that can be employed in the BERT module of Figure 5 and a fault prediction machine learning algorithm.

[0045] Fig. 7 is a block diagram for explaining the configuration that can be employed in the CNN model in the failure prediction module of the virtual machine failure prediction system of Fig. 1 and the combined relationship with the BERT model.

[0046] Figure 8 is an example diagram illustrating a structure and a failure prediction machine learning algorithm that can be employed in the CNN model of Figure 7.

[0047] FIG. 9 is a flowchart illustrating a virtual machine failure prediction method according to another embodiment of the present invention.

[0048] FIG. 10 is an exemplary diagram illustrating a network function virtualization infrastructure (NFVI) environment that can be employed in a virtual machine failure prediction device according to another embodiment of the present invention.

[0049] FIG. 11 is a schematic block diagram illustrating a configuration that can be employed in a virtual machine failure prediction device according to another embodiment of the present invention.

[0050] The present invention is susceptible to various modifications and embodiments. Specific embodiments are illustrated and described in detail in the drawings. However, this is not intended to limit the present invention to specific embodiments, but rather to encompass all modifications, equivalents, and alternatives falling within the spirit and technical scope of the present invention.

[0051] While terms such as "first" and "second" may be used to describe various components, these components should not be limited by these terms. These terms are used solely to distinguish one component from another. For example, without departing from the scope of the present invention, a first component may be referred to as a "second component," and similarly, a second component may also be referred to as a "first component." The term "and / or" includes a combination of multiple related items described herein or any of multiple related items described herein.

[0052] In the embodiments of the present application, 'at least one of A and B' may mean 'at least one of A or B' or 'at least one of combinations of one or more of A and B'. Furthermore, in the embodiments of the present application, 'at least one of A and B' may mean 'at least one of A or B' or 'at least one of combinations of one or more of A and B'.

[0053] When a component is referred to as being "connected" or "connected" to another component, it should be understood that it may be directly connected or connected to that other component, but that there may be other components in between. Conversely, when a component is referred to as being "directly connected" or "connected" to another component, it should be understood that there are no other components in between.

[0054] The terminology used in this application is only used to describe specific embodiments and is not intended to limit the present invention. The singular expression includes the plural expression unless the context clearly indicates otherwise. In this application, it should be understood that the terms "comprises" or "has" are intended to specify the presence of a feature, number, step, operation, component, part, or combination thereof described in the specification, but do not exclude in advance the possibility of the presence or addition of one or more other features, numbers, steps, operations, components, parts, or combinations thereof.

[0055] Unless otherwise defined, all terms used herein, including technical or scientific terms, have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains. Terms defined in commonly used dictionaries should be interpreted as having a meaning consistent with their meaning in the context of the relevant technology, and will not be interpreted in an idealized or overly formal sense unless explicitly defined herein.

[0056] Hereinafter, with reference to the attached drawings, preferred embodiments of the present invention will be described in more detail. In order to facilitate an overall understanding in describing the present invention, identical reference numerals will be used for identical components in the drawings, and redundant descriptions of identical components will be omitted.

[0057] FIG. 1 is a schematic block diagram illustrating an OpenStack-based network function virtualization environment of a virtual machine failure prediction system according to an embodiment of the present invention. FIG. 2 is an exemplary diagram illustrating a log data collection process in the virtual machine failure prediction system of FIG. 1. FIG. 3 is a block diagram illustrating a configuration that can be employed in a monitoring node of the virtual machine failure prediction system of FIG. 1.

[0058] Referring to FIG. 1, the virtual machine failure prediction system may include a controller node (Controller Node, 100), a computing node (Computing Node or Compute Node, 200), a monitoring node (Monitoring Node, 300), and a failure prediction module (Failure Prediction Module, FPM, 500).

[0059] Each of the controller node (100), computing node (200), monitoring node (300), and failure prediction module (500) can be independently installed by a server or computing device, and can be configured to be connected to each other through a network or communication network to transmit and receive signals and data.

[0060] A virtual machine failure prediction system can be built using OpenStack, a widely used cloud computing management system, and Network Function Virtualization Infrastructure (NFVI).

[0061] In this specification, a virtual machine failure prediction device included in a virtual machine failure prediction system may be configured to include a failure prediction module (500), or may be configured to include a failure prediction module (500) and a monitoring node (300). Such a failure prediction module (500) or a virtual machine failure prediction device including the same may be configured to be applied to failure prediction of a server of a specific computing device and / or a virtual machine of the server after learning is completed.

[0062] Each component of the virtual machine failure prediction system is described in more detail as follows.

[0063] First, as illustrated in FIGS. 1 and 2, the controller node (100) can manage the network connection of each virtual machine (VM) of the computing node (200) and set up service function chaining (SFC) of the computing node (200).

[0064] The controller node (100) can change the configuration and arrangement of virtual network functions and / or service function chaining by transmitting a pre-determined network management policy to the computing node (200). The network management policy may not be applied to the computing node (200) during the data collection step described below.

[0065] A computing node (200) is equipped with processing resources, memory, peripheral devices, networking modules, etc., and can be configured to operate a plurality of virtual network functions (VNFs) on virtual machines that are independently operated on each server of the processing resources.

[0066] For example, a computing node (200) may include multiple servers, such as a first server (210) and a fifth server (250). A first virtual machine (VM A, 211), a second virtual machine (VM B, 212), a fifth virtual machine (VM E, 215), etc. may be installed on the first server (210). Similarly, multiple virtual machines (e.g., VM F, VM G, etc.) may also be installed on the fifth server (250).

[0067] The computing node (200) may further include a state checker (217) as shown in FIG. 2. The state checker (217) may be implemented as a virtual machine installed on the first server (210), but is not limited thereto, and may be installed on another server of the computing node (200) or implemented as an independent means or component that performs the corresponding function in the computing node (200).

[0068] Logs (Log) such as logs generated from each server of the computing node (200), for example, the first server (server 1, 210) (server 1 log), logs generated from the first virtual machine (211) (VM A log), logs generated from the second virtual machine (212) (VM B log), and logs generated from the fifth virtual machine (215) (VM E log) can be collected by the monitoring node (300). In addition, the failure history of virtual machines (VMs failure history) (see 340 in FIG. 3) confirmed by the status checker (217) can also be collected by the monitoring node (300).

[0069] Additionally, the computing node (200) can deploy Service Function Chaining (SFC) using virtual network functions, thereby providing network functions based on Network Function Virtualization (NFV) to subscribers or clients.

[0070] The monitoring node (300) collects and monitors data in a network function virtualization environment. The monitoring node (300) can store data on logs and failure history. To this end, the monitoring node (300) may be equipped with an rsyslog server (320) that collects logs and a failure history database (340), as illustrated in FIG. 3. The term "rsyslog server" may be an abbreviation for "The rocket-fast syslog server."

[0071] That is, the monitoring node (300) can collect logs by utilizing the log collection utility, Alsyslog server (320), in order to use the log data for predicting failure of virtual machines for each server. In addition, the collected logs can be stored in the storage of the monitoring node (300). For example, the monitoring node (300) can collect logs from each server (210, 250) of the computing node (200) and virtual machines (e.g., 211, 212, 215) operating on each server (210, 250).

[0072] Logs collected in the monitoring node (300) may include kernel logs, application logs, system daemon (Systemd) logs, etc. generated in the virtual machine.

[0073] Additionally, the logs collected by the monitoring node (300) may include server application logs generated by the cloud computing management system used to build the server's NFVI. For example, in the case of OpenStack-related applications running on a server that generate logs of approximately 10 lines per second, the collected logs may include logs from Neutron, Nova, Open vSwitch (OVS), and the like, which are software used for network management.

[0074] Referring back to FIGS. 1 to 3, the failure prediction module (500) can receive log data from the monitoring node (300). The log data can include logs of virtual machines (211, 212, 215) and failure-related logs based on failure histories of the virtual machines (211, 212, 215). In addition, the failure prediction module (500) can predict the probability of failure of a virtual machine for each server and then provide failure information (Failure info) of the virtual machine obtained as a result of the prediction to the controller node (100).

[0075] To perform the aforementioned functions, the fault prediction module (500) may be equipped with a BERT module (520) and a CNN model (530). In addition, the fault prediction module (500) may further be equipped with a preprocessing unit (510). The structure and function of the preprocessing unit (510), BERT module (520), and CNN model (530) will be described in detail below.

[0076] In this way, in order to train the virtual machine failure prediction module (500) employed in the virtual machine failure prediction system of the present embodiment, it is necessary to collect not only the logs of each virtual machine and server used as input for the machine learning model, but also data or information on whether a failure has occurred. To this end, in the learning process of the present embodiment, at least one of the virtual machines in a single server is installed as a state checker, and a ping message is sent to the remaining virtual machines at regular intervals, for example, at intervals selected between several tens of seconds and several minutes (preferably, every minute), to check whether a failure has occurred in the network function of each virtual machine. The ping message may correspond to a packet of a certain size or a test signal.

[0077] If there is no response to the ping message, the status checker (217) can classify the virtual machine as a failure and store the time of failure. Virtual machine failure history data (hereinafter also referred to as “failure history data”) that records real-time failure status for each virtual machine can be transmitted from the status checker (217) to the monitoring node (300). At this time, the failure history data can be stored in a preset format, such as a YAML file that uses the yml or yaml extension and follows specific syntax rules, to record the time when a failure occurred in the virtual machine.

[0078] The function of recording whether a virtual machine has failed or the component implementing the function of recording whether such a virtual machine has failed may be omitted during the test operation of the device that predicts the probability of failure of a virtual machine for each server by executing the virtual machine failure prediction method of the present embodiment after the pre-training process.

[0079] Additionally, the virtual machine failure prediction system of the present embodiment is configured to predict virtual machine failures on a per-server basis, rather than on a per-virtual machine basis. This is because the virtual machine environment is a complex and sensitive system, and thus the causes of virtual machine failures are diverse.

[0080] For example, a kernel error in a specific virtual machine could trigger a server failure, potentially leading to failures in other virtual machines running on the same server. Because these types of failures cannot be predicted based on individual virtual machine logs, this embodiment uses the logs of all virtual machines running on the same server to predict the probability of a virtual machine failure on a server-by-server basis.

[0081] The collected log and failure history data are used to generate input log data (hereinafter also referred to simply as 'input data') of the machine learning-based failure prediction model of the present embodiment, and can be used to train the failure prediction model together with output data corresponding to the input data. In particular, since the virtual machine failure prediction system of the present embodiment predicts the failure probability of a virtual machine for each server, the logs of the virtual machines for each server can be configured to be combined for each server based on the recording time of the logs of the virtual machines for each server and the recording time of the failure history data, i.e., the logs of each virtual machine collected for a preset time, that is, a preset window size of an individual window in which the logs of each virtual machine are recorded.

[0082] The process of merging the collected server logs and virtual machine logs by server can be configured to sequentially merge the logs of the virtual machines with the server logs according to the preset serial order of the virtual machines.

[0083] Additionally, the process of merging logs by server can be configured to merge the logs of virtual machines into a single input window based on the time or timestamp at which the logs of each virtual machine were recorded. In other words, the process of merging logs by server can be configured to sort all logs chronologically in the input window where the logs of the server and the logs of the virtual machines are merged based on the time information extracted from the logs.

[0084] FIG. 4 is an exemplary diagram illustrating a process of tagging failure data for each server in a log data generation process that can be employed in the virtual machine failure prediction system of FIG. 1.

[0085] Referring to FIG. 4, in the virtual machine failure prediction system, the log data entered into the input window is used as the input of the machine learning model to train the machine learning model, and the input data and output data of the machine learning model can be generated so that whether or not a failure occurs after a certain time gap is used as the output of the machine learning model.

[0086] In particular, the virtual machine failure prediction system can generate input data by combining the logs of all virtual machines operating on a specific server and the logs of the server based on the timestamp of each log during an input window to create server-specific failure data.

[0087] At this time, the input window is a buffer memory with a preset input window size, and the predicted time gap between the input window size and the failure history in which the network status of the virtual machines is recorded may correspond to a parameter that the user can adjust during the learning process. In other words, since the input window is generated by sliding log data, the amount of logs can be controlled by adjusting the sliding window size.

[0088] For example, if the input window size is 10 minutes and the sliding size is 5 minutes, the logs within the 10-minute input window become the input data. Each input log is labeled as a failure if the failure history is marked as a "failure" after the "gap" period from the end of the input window, and is labeled as normal if the failure history is marked as normal after the "gap" time.

[0089] As another example, if the input window size is set to 20 minutes and the prediction time difference is set to 10 minutes, the logs of each virtual machine and the server logs from 12:10 to 12:30 can be used as input data to predict whether a failure will occur at 12:40.

[0090] That is, the output data of the failure prediction model can be generated to include newly tagged data based on whether any of the virtual machines running on the server have experienced a failure. The newly tagged data may include data labeled as "failure," for example.

[0091] For example, as shown in FIG. 4, the logs of all virtual machines within a specific server, including the logs of the first virtual machine collected in the first input window (211g) and the logs of the fifth virtual machine collected in the fifth input window (215g), and the server logs collected in the server log input window (210g), can be combined into a single input window (WSa, 216g) (hereinafter referred to as a “combined input window”).

[0092] In addition, the failure histories of all virtual machines, including the failure history (211f) of the first virtual machine and the failure history (215f) of the fifth virtual machine, can be merged into a single failure history (218f) (hereinafter referred to as the "integrated failure history"). At this time, it can be seen that the logs of each virtual machine are newly created as failure-related logs of the server based on the failure histories (211f, 215f) of the corresponding virtual machines. The failure-related logs of a specific server can be sequentially recorded according to the time of the corresponding timestamp as a failure history labeled as "failure."

[0093] Meanwhile, input log data generated from input data may undergo a preprocessing process before being used as input for machine learning in the failure prediction module (500). The preprocessing process may be performed by a preprocessing unit. If the function of the preprocessing unit is integrated into the rear end of the monitoring node or the front end of the BERT module, the independently installed preprocessing unit may be omitted.

[0094] The failure prediction process of this embodiment uses not only the logs of a single virtual machine, but also the logs of multiple virtual machines and the servers on which they operate. Therefore, the number of input logs is relatively large. In particular, OpenStack-related applications running on servers (e.g., Neutron, Nova, OVS) generate nearly 10 lines of logs per second. In this case, even reading the logs takes a long time, not to mention the performance of the machine learning model. Therefore, preprocessing is required to reduce the number of logs.

[0095] To meet these requirements, the preprocessing process of the present embodiment may be configured to remove unnecessary logs from the log data. The preprocessing process may include removing the date and the application name that generated the log, the process name, etc., based on preset rules, or removing numbers and / or symbols based on preset rules.

[0096] Additionally, the preprocessing step can be configured to remove the addresses of major registers in the kernel logs, which are periodically output when the virtual machine logs are kernel logs. This kernel log preprocessing step is a simple process that searches for unnecessary patterns in the logs without requiring any additional background knowledge, making it easily applicable to new types of logs.

[0097] Additionally, in a virtual machine failure prediction system, if the computing resources of the server used for failure prediction are insufficient, some logs can be removed to reduce the amount of input data to improve efficiency. Log removal can be performed based on preset rules.

[0098] For example, it can be configured to remove logs that are completely unrelated to the failure, such as server remote login (Secure Shell, ssh) login logs, package update logs, etc., based on preset rules.

[0099] Even after going through the above process, if the amount of logs is too large and learning is not working well, only logs with a high probability of being related to a failure can be left as a rule-based system.

[0100] For example, you can pre-select a list of the most frequently printed words from log data when a failure occurs among the collected data, and based on this, only logs containing those words can be recorded. These words could include reset, fail, not, failure, timeout, kill, error, out of memory (oom), stop, exit, restart, long, and warn.

[0101] The various types of preprocessing processes described above can be set to be automatically selected based on the performance of the module by a network administrator who can access the virtual machine failure prediction system during the pre-training stage of the failure prediction module.

[0102] FIG. 5 is a block diagram illustrating a configuration that can be employed in the BERT (Bidirectional Encoder Representations from Transformers) module within the failure prediction module of the virtual machine failure prediction system of FIG. 1. FIG. 6 is an exemplary diagram illustrating the structure of a BERT tokenizer and BERT model that can be employed in the BERT module of FIG. 5, as well as a failure prediction machine learning algorithm.

[0103] This example illustrates the structure of a Bidirectional Encoder Representations from Transformers (BERT) module that can be employed in a fault prediction module. Furthermore, we describe a BERT module that utilizes the structure of the BERT-Base model, one of two BERT models trained and released by Google.

[0104] The BERT-Base model is a public model and can be used as part of the BERT-CNN model proposed in this embodiment. Since the BERT module (520) in this embodiment includes a language model, it can be further trained to suit any desired task even after pre-training, and can be configured to generate numerical vectors that are not biased against the pre-training corpus.

[0105] That is, in this embodiment, by performing fine tuning through backpropagation during the pre-training process, it is possible to train a machine learning model such as the BERT-Base model to be suitable for virtual machine failure prediction based on log analysis by solving the problem of different types or meanings of words used in a large corpus for pre-training and logs.

[0106] Referring to FIGS. 5 and 6, the BERT module (520) may include a BERT tokenizer (522) and a BERT model (524).

[0107] The BERT module (520) can be designed using only an encoder from a Transformer, one of the sequence-to-sequence (seq2seq) models. The BERT model (524) for predicting failures of a virtual machine in this embodiment can be configured by overlapping 12 layers of Transformer Encoders.

[0108] Although a model with improved performance can be used by using more transformer encoders, since this takes longer to train, the BERT model (524) of the present embodiment may be configured so that the network administrator selects the number of transformer encoders of the BERT model (524) according to which of the training time and model performance is more important.

[0109] The BERT module (520) splits words into smaller subwords and uses them as input, so it is used in conjunction with the BERT tokenizer (522). In this embodiment, the BERT tokenizer (522) distinguishes the stem and ending of each word and transforms the word into its original form. That is, as shown in FIG. 6, 'failed' can be split into 'fail' and '-ed'. In addition, a special token, i.e., the [CLS] token, indicating the beginning of each sentence can be added.

[0110] The aforementioned [CLS] token is a special token that represents the entire sentence as a single vector, i.e., a vector that integrates the meaning of the words in the entire sentence. The output word vector can be used as a sentence vector representing the meaning of the sentence. Therefore, when using the BERT-CNN model of the present embodiment (see Fig. 7), the virtual machine failure prediction system can be configured to use only the output vector of the [CLS] token instead of combining the remaining word vectors to reduce training time.

[0111] In addition, the BERT module (520) of the present embodiment uses the position embedding (E2) indicating the position of each subword token within a sentence combined with each token embedding (E1) as input to the nested transformer encoders, thereby operating to analyze the context while preserving the order of each word.

[0112] In this way, log files containing logs of virtual machines and server logs within the same server during the input window size that has undergone the preprocessing process can be used as input to the BERT-CNN model. Each log within the log file is separated into sub-word tokens by the BERT tokenizer (522) and converted into an embedding of a token set, which can then be used as input to the pre-trained BERT model (524).

[0113] The BERT module (520) of this embodiment can ultimately output a vector of a constant size for each subword token as an output embedding (E5). In the case of the BERT-Base model, the output embedding (E5) can generate a 768-dimensional vector for each subword token.

[0114] Figure 7 is a block diagram illustrating a configuration that can be employed in the CNN model within the failure prediction module of the virtual machine failure prediction system of Figure 1 and its relationship with the BERT model. Figure 8 is an exemplary diagram illustrating a structure and a failure prediction machine learning algorithm that can be employed in the CNN model of Figure 7.

[0115] In this embodiment, the structure of a CNN model that can be employed in a virtual machine failure prediction system and a failure prediction machine learning algorithm applied to this structure are described.

[0116] Referring to FIG. 7, the failure prediction module may have a structure that combines a BERT model (524) and a CNN model (530). The failure prediction module may be referred to as a failure prediction model. The failure prediction model may use the BERT model (524) to convert log data into a numerical matrix, i.e., a log embedding, and may use a convolutional neural network model (530) to analyze the numerical matrix and calculate a failure probability.

[0117] The general BERT model is a language model released by Google in 2018, and like word embedding, it is used to receive words as input and generate numeric vectors representing the meaning of the words. However, the BERT model (524) of this embodiment, unlike the word embedding technique, applies a methodology to generate different vectors depending on the context even for the same word. That is, the BERT model (524) is pre-trained based on log data tagged with the presence or absence of a failure, and then is configured to output different embeddings even for the same word by identifying the context of the sentences in the input log data.

[0118] The BERT model (524) of this embodiment may be a language model pre-trained from a large corpus without labels, and by applying additional learning, i.e., fine-tuning, to suit the task to be solved in this embodiment, a numerical vector suitable for the task may be generated, thereby exhibiting higher performance than existing word embedding-based models.

[0119] Additionally, the BERT model (524) generates a numeric vector for each subword token. During the pre-training process of the BERT-CNN model, backpropagation occurs between the CNN model (530) and the BERT model (524), and through this backpropagation, additional learning is performed through fine-tuning in the BERT model (524), whereby the BERT model (524) can be trained to generate a word vector suitable for fault prediction for each token.

[0120] The numerical vectors generated by the BERT model (524) can be concatenated to be used as input for the CNN model (530). The concatenation process does not involve adding vectors, but rather creating a matrix by overlapping each vector. This matrix transformation is possible because the BERT model (524) outputs a vector of the same dimension for each subword token. The matrix generated by this matrix transformation can be determined by the product of the dimensions of the output layer of the BERT model (524) and the number of subword tokens included in the input log.

[0121] The CNN model (530) is a machine learning algorithm that performs convolution operations as kernels move through a matrix, extracting key data from a large amount of data. To allow the kernels to move downward within the matrix, the number of columns and rows can be set to be the same as the matrix, but with a different number of rows.

[0122] For example, the input matrix of the CNN model (530) becomes a two-dimensional matrix composed of the dimension (D1) of the output layer of the BERT model (524) and the number of subword tokens (N1) included in the input log. That is, the kernel corresponding to the vectors from each sentence can be a two-dimensional matrix by the dimension (D1) of the output layer or hidden layer of the BERT model (524) and a preset kernel size. If the BERT model (524) is a BERT-Base model, the dimension (D1) of the aforementioned output layer or hidden layer can be 768. At this time, the kernel size can be freely set by the network administrator as the number of rows of the kernel matrix different from the number of subword tokens (N1) included in the input log. When using such a CNN model (530), the convolution operation can be configured by using, for example, 100 kernels each having kernel sizes of 3, 4, and 5.

[0123] Meanwhile, when the input log volume is large, a larger kernel can be used to further compress the data. When the input log volume is small, a smaller number of kernels can be used. Since there is no single correct answer for kernel size, the fault prediction module can be configured to use an appropriate kernel size or number of kernels based on the logs of the network to be used in the pretraining phase.

[0124] In the pre-training stage, the kernel of the CNN model (530) can be trained to extract data related to a failure through backpropagation. That is, the CNN model (530) can be equipped with a convolutional layer (532) in which the kernels perform a convolution operation. Then, a max-pooling layer (534) that retains the highest value for each kernel output can be placed after the convolutional layer (532). By retaining the highest data through the max-pooling layer (534), only the most important values ​​as data related to a failure can be retained in the CNN model (530).

[0125] When a vector with the number of dimensions equal to the number of kernels is generated through the max-pooling layer, this vector can be used as the input of a fully-connected layer (FC Layer, 536) to calculate a failure prediction probability between 0 and 1. A fully-connected layer (536) means a layer in which all neurons are connected to all neurons in the next layer, and although the input is a high-dimensional vector, the output is a single value, so it can be implemented in a simple form of multiplying the output value of the max-pooling layer by a weight and adding it.

[0126] This fully connected layer (536) can be connected to the end of a machine learning model and used to classify the output (550) according to the task to be solved. The output can be referred to as a learning result or a prediction result. In a CNN model (536), the kernels and weights of the fully connected layer (536) can be learned through backpropagation during the pre-training stage.

[0127] Additionally, for learning in the pre-training phase, failure history data as well as log data can be collected in the data collection environment illustrated in FIGS. 1 to 3. In this case, since the failure prediction model aims to calculate the probability of a failure occurring after a certain period of time, for example, in the learning phase, if any of the virtual machines included in the server are tagged as failed after a certain period of time from the input log, the output value can be configured to be 1, and if all virtual machines are in a normal state, the output value can be 0.

[0128] In the pre-training step described above, if the final output value is close to 0 but is actually a failure, each element of the BERT model (524) and the CNN model (530) will be modified through backpropagation. Similarly, if the output value is close to 1 but is actually normal, each element can be modified through backpropagation. In this way, the BERT-CNN model can be trained to effectively classify failures and normal conditions through input logs. This pre-trained BERT-CNN model can be used in a log-based failure prediction model within the same network.

[0129] Meanwhile, failure-related logs sometimes originate from server logs or other virtual machines, not the faulty virtual machine. In these cases, the input window marked as "failure" does not contain the failure-related log sequence, while the input window containing the failure-related logs displays as normal, which can prevent the machine learning model from properly training.

[0130] Accordingly, the failure prediction module of the present embodiment may be configured to use the log of the server and the logs of all virtual machines of the server together, and to display the corresponding log in the input window as a failure if any of the virtual machines operating on the server has a failure log.

[0131] Additionally, in this embodiment, the failure prediction module may be configured to change the input window size only for the window of a specific virtual machine marked as failed when generating training data for training a machine learning model.

[0132] That is, during the pre-training process, the failure prediction module can set the input window size to, for example, 10 minutes by default, and change the window size only for the input window in which the failure-related logs occur to an input window size of 28 minutes. In this case, all logs from 30 minutes to 2 minutes before the failure occurrence time can be used as input. In other words, to take action after the failure is predicted, the failure prediction module may require a minimum time interval from the predicted failure time, and in one embodiment, the interval can be minimized to 2 minutes.

[0133] Here, the window size is assumed to have a maximum value of 30 minutes. If the maximum value of the window size changes, the window size of the input window in which the failure-related log occurs can be appropriately changed accordingly.

[0134] Meanwhile, the problem of varying window sizes in the input window and the amount of input logs for the machine learning model varying depending on the window size may arise. However, the CNN model (530) learns by extracting only important data from a large amount of data.

[0135] That is, since the failure prediction module of the present embodiment uses a max pooling layer as the pooling layer of the CNN model (530), if the CNN model (530) is trained properly, it can operate to selectively find only messages related to failures or malfunctions of the virtual machine, regardless of the amount of input data. Therefore, changes in the size of the input data in the CNN model (530) do not affect performance.

[0136] In this way, the labeling method of changing the window size of the input window in which the aforementioned failure-related logs occur can improve the performance of a machine learning model using a CNN model (530).

[0137] FIG. 9 is a flowchart illustrating a virtual machine failure prediction method according to another embodiment of the present invention.

[0138] Referring to FIG. 9, the virtual machine failure prediction method may include a pre-training step (S910) based on log data tagged with failure status. The pre-training step (S910) may include a process of fine-tuning the CNN model and the BERT model using backpropagation of the CNN model and the BERT model. Through fine-tuning, the entire hyperparameters of the pre-trained language model may be modified to be more suitable for log-based virtual machine failure prediction.

[0139] Additionally, the virtual machine failure prediction method may further include a step of generating learning data prior to the pre-training step (S910). The learning data generation step may include a process of sending packets or test signals of a certain size to each virtual machine, receiving response messages for the packets or test signals, and analyzing the response messages to determine the network connection status of each virtual machine.

[0140] Next, a step (S920) of collecting logs generated from each virtual machine and the server that operates the virtual machine may be included. The log collection step (S920) may include a process of merging logs recorded in the input window of each virtual machine in each server of the computing node into the integrated input window of the monitoring node, and merging the failure histories of each virtual machine into the integrated failure history of the monitoring node. Input log data including the integrated input window and the integrated failure history may be transmitted from the monitoring node to the failure prediction module.

[0141] Next, a step (S930) may be included in which the collected log, i.e., input log data, is used as input to the BERT module and converted into a log embedding matrix, which is a numerical matrix representing the characteristics of the log. In the matrix conversion step (S930), a BETR tokenizer that converts input log data into subword tokens and a BERT model that converts subword tokens into embeddings may be used.

[0142] Next, a step (S940) may be included for predicting the probability of a virtual machine failure for each server using a pre-trained CNN model based on the transformed log embedding matrix. In the CNN model, the kernels and the weights of the fully connected layer can be learned through backpropagation in the pre-training step. In this CNN model, a convolution operation is performed on vectors from each sentence in the input log data, and only the data with the largest value among the results of the convolution operation of the kernel is left through a max-pooling layer, and the failure prediction probability can be calculated by outputting the vector data with the largest value, which has as many dimensions as the number of kernels, as a single value through a fully connected layer.

[0143] Next, a step (S950) may be included for determining a failure handling method based on the predicted probability of virtual machine failure per server. The failure handling method may include transferring virtual machines of a server predicted to fail to a server predicted to fail within a predetermined time period to a server predicted to fail within a predetermined time period.

[0144] Figure 10 is an exemplary diagram illustrating a Network Function Virtualization Infrastructure (NFVI) environment that can be employed in a virtual machine failure prediction device according to another embodiment of the present invention. The NFVI environment of this embodiment can be applied to a failure prediction module based on the BERT-CNN model.

[0145] Referring to Fig. 10, the BERT-CNN model, as one of the models that can be employed in the Failure Prediction Module, can be installed as a separate server or node on the network. In the NFVI environment, as in the data collection phase, the monitoring node (300) can collect logs from each virtual machine installed on the server of the computing node (200) and logs from the corresponding server.

[0146] In the monitoring node (300), as in the data collection phase, an input window can be generated by combining all logs of each virtual machine and server during the input window time. The log data during the generated input window can be transmitted as input to the failure prediction module (500).

[0147] The failure prediction module (500) can be configured to convert each sentence of log data into subword tokens by the BERT tokenizer, as in the pre-training stage, and then convert them into a numerical matrix using them as inputs to the BERT model, and then use them as inputs to the CNN model to ultimately calculate the probability of failure occurrence after a certain period of time. At this time, the size of the input window and the time gap from the failure prediction time can be set to appropriate values ​​by the network manager in the pre-training stage based on whichever is more important: urgency or prediction accuracy.

[0148] If the calculated value exceeds a certain threshold, the probability of a failure is determined to be high, and thus the prediction result is transmitted to the controller node (100). The controller node (100) can transmit a command to the computing node (200) to perform a failure mitigation task set in advance by the network manager based on the transmitted prediction result.

[0149] The virtual machine failure prediction device (1000) of the present embodiment can be configured to include a monitoring node (300) and a failure prediction module (500), and can be implemented to calculate the probability of a virtual machine failure occurring for each server. Since the probability of a virtual machine failure occurring is calculated for each server, the controller node (100) that receives the prediction result from the virtual machine failure prediction device (1000) can migrate the virtual machine from a server predicted to have a high probability of failure occurring to a server predicted to have a low probability of failure occurring.

[0150] Although this embodiment expresses that the network administrator can directly set various parameters, this is not limited to this. In this embodiment, parameters such as whether to use the BERT-Base model or the BERT-Large model, the size and number of kernels to use, the size of the input window to use, and the time difference from the failure prediction point in time, which are not precisely specified, are factors that determine how long training takes, how long it takes to calculate the prediction result, and the prediction accuracy. Therefore, the network administrator can be configured to set appropriate values ​​according to the performance of the server on which the failure prediction module will be installed and the importance of failure prediction accuracy. As the value of each parameter increases, the failure prediction accuracy increases, but more computing resources must be used to train and calculate the failure probability value, and learning may take longer, so an appropriate trade-off may be applied.

[0151] FIG. 11 is a schematic block diagram illustrating a configuration that can be employed in a virtual machine failure prediction device according to another embodiment of the present invention.

[0152] Referring to FIG. 11, a virtual server failure prediction device (1000) may include a failure prediction module or may be configured to include a failure prediction module and a monitoring node. This virtual server failure prediction device (1000) may include at least one processor (1100) and memory (1200).

[0153] In addition, the virtual server failure prediction device (1000) may further include a transmission / reception device (1300) that is connected to a network and performs communication. In addition, the virtual server failure prediction device (1000) may be configured to further include an input interface device (1400), an output interface device (1500), a storage device (1600), etc. Each component included in the virtual server failure prediction device (1000) may be configured to be connected by a bus (bus, 1700) and communicate with each other.

[0154] The processor (1100) can execute program commands stored in at least one of the memory (1200) and the storage device (1600). The processor (1100) may refer to a central processing unit (CPU), a graphics processing unit (GPU), or a dedicated processor on which methods according to embodiments of the present invention are performed.

[0155] Each of the memory (1200) and the storage device (1600) may be configured with at least one of a volatile storage medium and a non-volatile storage medium. For example, the memory (1200) may be configured with at least one of a read-only memory (ROM) and a random access memory (RAM).

[0156] The transceiver (1300) may include a communication interface or sub-communication system for short-range wireless networks or cable connections, communication with satellites, wired or wireless communication with universal base stations, connection of an ideal backhaul link or non-ideal backhaul link with a mobile edge core network or core network, etc.

[0157] The input interface device (1400) may include at least one input means selected from input means such as a keyboard, microphone, touchpad, and touch screen, and an input signal processing unit that maps or processes a signal input through at least one input means to a pre-stored command.

[0158] The output interface device (1500) may include an output signal processing unit that maps or processes a signal output under the control of the processor (1100) into a pre-stored signal form or level, and at least one output means that outputs a signal or information in the form of vibration, light, etc. according to a signal from the output signal processing unit. The at least one output means may include at least one selected from output means such as a speaker, a display device, a printer, an optical output device, and a vibration output device.

[0159] The methods according to the present embodiment described above may be implemented in the form of program commands that can be executed by various computer means and recorded on a computer-readable medium. The computer-readable medium may include program commands, data files, data structures, etc., either singly or in combination. The program commands recorded on the computer-readable medium may be those specifically designed and configured for the present invention, or may be known and usable by those skilled in the art of computer software.

[0160] Examples of computer-readable media include hardware devices specifically configured to store and execute program instructions, such as ROM, RAM, and flash memory. Examples of program instructions include not only machine language codes generated by a compiler, but also high-level language codes that can be executed by a computer using an interpreter, etc. The hardware devices described above may be configured to operate with at least one software module to perform the operations of the present invention, and vice versa.

[0161] Although the present invention has been described with reference to the above embodiments, it will be understood by those skilled in the art that various modifications and changes can be made to the present invention without departing from the spirit and scope of the present invention as set forth in the claims below.

Claims

1. In a machine learning-based virtual machine failure prediction method, A step of acquiring log data by combining logs generated from each virtual machine installed on a server operating in a network function virtualization environment and operating a virtual network function or web server with the log of the server; A step of converting the above log data into a log embedding matrix, which is a numerical matrix representing the characteristics of the log, using the log data as input to a pre-trained language model; and A step of predicting the probability that a failure will occur in virtual machines of each server within a certain period of time using a convolutional neural network model that takes the above log embedding matrix as input; Including, A method for predicting virtual machine failure, wherein the log data includes failure-related logs based on logs of the virtual machines and failure histories of the virtual machines.

2. In claim 1, A method for predicting a virtual machine failure, wherein the above language model is a model that is pre-trained based on log data tagged with a failure status and outputs different embeddings for the same word by understanding the context of sentences in the log data.

3. In claim 2, A method for predicting virtual machine failure, wherein the language model divides the word into smaller subwords and uses them as tokens to generate an output embedding for each token.

4. In claim 3, A method for predicting virtual machine failure, wherein the above language model and the above convolutional neural network model are fine-tuned through backpropagation during a pre-training process, and the entire hyperparameters of the language model are modified through the fine-tuning.

5. In claim 1, A method for predicting virtual machine failure, further comprising a step of preprocessing the log data before the log data is input to a pre-trained language model.

6. In claim 5, A method for predicting a virtual machine failure, wherein when the log of a virtual machine operating the virtual network function or web server is a kernel log, the preprocessing includes removing the address of a major register of the kernel log based on a preset rule.

7. In claim 5, A method for predicting a virtual machine failure, wherein the above preprocessing includes leaving only logs that contain at least one word among preset words among the logs.

8. In claim 7, A method for predicting virtual machine failure, wherein the above words include at least some of reset, fail, not, failure, timeout, kill, err, out of memory (oom), stop, exit, restart, long, and warn.

9. In claim 5, A method for predicting a virtual machine failure, wherein the preprocessing includes a process of extracting time information and application information from the logs, a process of removing numbers and symbols from the logs, a process of changing uppercase letters to lowercase letters in the logs, or a combination thereof.

10. In claim 9, A virtual machine failure prediction method further comprising a step of chronologically sorting all logs of an input window in which the logs of the server and the logs of the virtual machines are combined based on time information extracted from the logs.

11. In claim 1, A step of merging logs generated from each of the above virtual machines and logs generated from the server into a single input window; and A method for predicting virtual machine failure, further comprising: a step of combining logs generated from each of the virtual machines and failure histories generated by checking the network connection status for each of the virtual machines into a single failure history.

12. In claim 1, In the above-mentioned predicting step, a step of determining a failure handling method for a virtual machine having a probability of failure occurring within the predicted predetermined time period is further included. A virtual machine failure prediction method, wherein the above failure handling method includes transferring virtual machines of a server predicted to fail within a certain period of time to a server predicted to fail within the certain period of time.

13. In claim 1, A method for predicting virtual machine failure, wherein at least some of the virtual machines are configured to pass through a plurality of virtual network functions configured with service function chaining to dynamically provide end-to-end services with other servers according to the type of server and traffic identification, and are configured to perform a message procedure for the service function chaining.

14. In claim 1, Further comprising a step of generating training data for training the above convolutional neural network model, A method for predicting virtual machine failure, wherein the step of generating the learning data includes sending a packet or test signal of a certain size to each of the virtual machines, receiving a response message for the packet or test signal, and analyzing the response message to check the network connection status of each of the virtual machines.

15. A virtual machine failure prediction device that performs a machine learning-based virtual machine failure prediction method, A processor comprising: a processor that executes program instructions stored in memory to predict a failure of a virtual machine based on machine learning; wherein the processor comprises: A pre-trained language model that converts log data generated from each virtual machine that is installed on a server operating in a network function virtualization environment and operates a virtual network function or a web server into a log embedding matrix, which is a numerical matrix representing the characteristics of the log, by combining the log data of the server as input; and A convolutional neural network model is provided that uses the above log embedding matrix as input to predict the probability that virtual machines on each server will fail within a certain period of time. A virtual machine failure prediction device, wherein the above log data includes failure-related logs based on the logs of the virtual machines and failure histories of the virtual machines.

16. In claim 15, A virtual machine failure prediction device, wherein the above pre-trained language model is a model that is pre-trained based on log data tagged with a failure, and then outputs different embeddings for the same word by understanding the context of sentences in the log data.

17. In claim 15, A virtual machine failure prediction device, wherein the above pre-trained language model and the above convolutional neural network model are fine-tuned through backpropagation during the pre-training process, and the entire hyperparameters of the above pre-trained language model are modified through the fine-tuning.

18. In claim 15, A virtual machine failure prediction device further comprising a preprocessing unit that preprocesses the log data before the log data is input to the pre-trained language model.

19. In claim 15, Further comprising a monitoring node that generates the above log data, The monitoring node is a virtual machine failure prediction device that combines logs generated from each of the virtual machines and logs generated from the server into a single input window, and combines logs generated from each of the virtual machines and failure histories of each of the virtual machines generated by the results of checking the network connection status for each of the virtual machines into a single failure history.

20. In claim 19, The above monitoring node is a virtual machine failure prediction device that sorts all logs of an input window in which the logs of the server and the logs of the virtual machines are combined in chronological order based on time information extracted from the logs.

Citation Information

Patent Citations

  • Automatic predicting system for server failure and automatic predicting method for server failure

    KR101984730B1

  • Fixing angle unit for seismic isolation and vibration control in exterior finishing materials

    KR1020240155022A

Cited By

  • Method and device for detecting root cause of defect of Ethereum virtual machine

    CN119668913A

  • Network fault prediction method and system

    CN119728397A

  • Cryptographic equipment fault diagnosis and repair system and method based on artificial intelligence

    CN120223306A