Patent Description:
Modem communication systems and applications, known from prior art, tend to generate copious amounts of operation logs. Due to the amount of information, lack of standard and general knowledge to interpret the information contained in these logs, a lot of expertise is needed for the analysis and evaluation. However, this is not only time-consuming, but it also requires a lot of resources, since specialists are needed to do the analysis.

On properly working environments, the logs usually display a known pattern of events. However, even with complex knowledge, it may be difficult for a specialist in this field to identify discrepant information that reflects an abnormality in the working environment. Therefore, errors may occur, since they are nearly impossible to be detected by human observation alone.

Basic concepts of self-learning methods for analyzing log events are described inter alia in <NPL>; <CIT> and <CIT>.

The present invention is based on the object to improve a telecommunication system and a computer-implemented method of detecting abnormal events in a telecommunication system that facilitate the work of an expert analyzing logs in log files so as to resolve abnormal events in telecommunication systems.

This object is solved according to the present invention by a computer-implemented method of detecting abnormal events in a telecommunication system having the features of claim <NUM> and a corresponding telecommunication system having the features according to claim <NUM>. Preferred embodiments of the invention are specified in the respective dependent claims.

Therefore, according to the present invention, a computer-implemented method of detecting abnormal events in a telecommunication system is provided, the method comprising a training phase and a production phase, wherein in the training phase, the method comprises the steps of recording data events in a log file during the execution of the system; creating a standard for the data events representing a properly working environment of the telecommunication system by applying a training procedure, wherein the properly working environment is characterized by a plurality of features, and a predetermined order of the features, wherein data events stored in a set of representative random samples of the stored log files are used for the training procedure; and wherein the production phase comprises the steps of receiving at least one new data event; and determining, whether the at least one new data event is a normal event that matches the standard, and if the at least one new data event matches the standard, using it for updating the standard, and if the at least one new data event does not match the standard, classifying and reporting it as an abnormal event, wherein the method further comprises a step of transmitting the at least one event to an autoencoder unit, the autoencoder unit comprising a deep encoder and a decoder, wherein the deep encoder transforms the at least one data event from a high-dimensional space into a series of codes in a low-dimensional space, and wherein the method further comprises a step of feeding the encoded data events to a Long Short-Term Memory, LSTM.

Thus, according to the inventive method, the number of logs that a specialist has to deal with is substantially reduced. All data events are detected and filtered so that only the abnormal events are transmitted further to a specialist to deal with the event, while normal events are used to keep the standard updated. Therefore, a specialist does not have to go through the log files himself; rather he or she only needs to take care of the abnormal events that are transmitted, thereby facilitating his work and making it more efficient. Also, by this automatic detection and filtering mechanism, errors may be prevented more reliably.

According to a preferred embodiment of the invention, a log analyzer is used for the training phase and/or in the production phase for receiving at least one log file output from the telecommunication system to be evaluated.

According to a further preferred embodiment of the invention, the method further comprises a step of extracting the at least one event from the log files.

According to still a further preferred embodiment of the invention, the method further comprises a step of tokenizing information of the at least one event.

Also preferably, the decoder has one layer for decoding features from the at least one event into a format that is readable by a human.

Still further, the method may comprise a step of feeding the encoded data events to a Convolutional Neural Network, CNN for classifying the at least one data event as a standard normal event or as an abnormal event that is a relevant event outside of the standard. Preferably, only data events that are categorized as an abnormal events are decoded by the decoder.

According to another preferred embodiment of the invention, the method further comprises a step of forming clusters of features that are classified by the CNN under the same class. Moreover, the at least one data event may be transcribed into features that describe the telecommunication system to be evaluated.

Further, according to the present invention, a telecommunication system is provided comprising a log analyzer that is adapted to carry out the method of detecting abnormal events in the telecommunication system.

According to a preferred embodiment, the log analyzer comprises an autoencoder unit comprising a deep encoder and a decoder.

Further advantages of the inventive method and system are that due to the grouping of features into clusters that represent as issues or expected behavior of the system under evaluation, the system is more flexible compared to systems that use pre-defined error clusters. Among these clusters, normal behavior, warning, errors, and unexpected behavior of the system under evaluation may be defined. Thus, flexibility is added to the log analyzer when encountering new issues or a different expected behavior, as the system adapts to these new situations.

Also, since the telecommunication system does not need the time elapsed between the recorded data events, but rather only considers the order and context of the data events for generating a feature cluster, again, flexibility is added on tackling complex log patterns that depend on asynchronous events comping from external subsystems, e.g., allowing for delays due to network, disk access, human interaction, etc. Tolerance to time and pattern variations ensure a larger delay allowance for classifying events correctly. In short, data events that would not be recognized as normal events due to their dependence on time variance may be recognized by the inventive solution.

Further, using a deep autoencoder that has the characteristic of condensing data and assigning a weight to each parameter provides several advantages. Namely, as data is condensed, meaning that the context in the log events is maintained up to a certain boundary, it may be represented in a lower dimension. Thus, high dimensional data may be represented on a lower dimension. This facilitates the learning process of the LSTM and CNN stage, as it presents features and weighs the values of each parameter that otherwise would not be present when employing simple tokenization. The deep autoencoder considerably reduces the amount of training data required to learn some functions.

Also, as the data is condensed, training of the LSTM and CNN stage with logs from complex systems is less prone to saturation or reaching a limit while learning new features. This means that no more modules of further scalation of the system is directly needed. This saves computing resources and processing from scaling the telecommunication system due to learning restrictions.

The invention and embodiments thereof will be described below in further detail in connection with the drawing.

<FIG> is a block diagram of a log analyzer according to an embodiment of the invention.

<FIG> is a block diagram of a log analyzer <NUM> according to an embodiment of the invention. The data flow concerning this embodiment, at first, may be summarized as follows. First, the system under evaluation has a set of logs that is going to be used for training. Then, in a subsequent step referred to as tokenization & sanitization, a decision is made what is going to be an unitary event; this may vary from system to system, as it may be a simple string, a message several lines long, or a single line. Further, in this step, unwanted characters are removed. Subsequently, so-called events are input into the deep encoder, and an event-feature map is obtained after training. Then, the features are input into a classifier block, first through an LTSM block and then through an CNN block, as will be outlined in further detail with reference to <FIG> below. Next, a feature cluster is received as an output. During the training phase all the feature cluster entries have to be decoded by means of the decoder layer of the autoencoder, as it is still unknown which ones are the normal events and which ones are abnormal events. It is noted that this has to be evaluated by an external agent, and this procedure will be a little bit different in the production phase, as here, only the abnormal events are of interest, so only these will be decoded. Further, it is noted that there are two different kinds of abnormal event, namely, an event which requires actions to be taken for or a new event that is normal. However, at its first appearance on the system, it will be flagged as abnormal. In these cases the external agent must flag it as a normal event so it would not be warned as an abnormal event when it appears again, this event is then fed again into the classifier block via the Long-Short term memory Network (LTSM).

In the following, the procedure will be explained in detail with reference to the several blocks of the block diagram shown in <FIG>. Here, in a first step, in the system under evaluation <NUM>, several log outputs are supplied to the log analyzer <NUM> either in the initial training phase or during the production phase, which is indicated as the first block <NUM>. Subsequently, as indicated by the second block <NUM> of the block diagram, data events are extracted from the log outputs whereby after undesired characters have been removed from the text in a sanitizing procedure, the data is tokenized according to known relevant information as, for example, standard headers, expected date and time format.

The next block <NUM> indicates "events". An event in this context can be understood as something that may be added as a unitary input to the autoencoder after the tokenization and sanitization process. In particular, an event may represent a unit of information which, for example, in a text would be either a phrase, a sentence, or a paragraph.

Then, the thus processed data is supplied to an autoencoder <NUM>. One of the characteristics of the autoencoder <NUM> is that no manually pre-classified or pre-labeled events are needed. This plasticity is useful for the function of the log analyzer <NUM> described here, since it ensures that features of the data events stored in the log files may be extracted in an automated manner, not depending on manual techniques or overly specialized techniques for feature extraction in each system which may be monitored by the log analyzer <NUM> according to this embodiment. Basically, the autoencoder <NUM> comprises one encoder <NUM> and one decoder <NUM>. The encoder <NUM> of this embodiment actually is a series of stacked encoders, with multiple layers, denominated as deep encoder and further described below. It is responsible for extracting the features of the data events automatically. The decoder <NUM> has a single layer for decoding features of the data events into simplified events that may be analyzed by an external agent <NUM>. Namely, the decoder <NUM> has the task of reconstructing simplified events from the corresponding features. The reconstructed simplified event contains only the relevant information extracted by the tokenize and sanitize block <NUM> and processed by the encoder <NUM>. This is necessary for the features to be converted in a human readable format so that the external agent <NUM> may be able to analyze the output concerning abnormal events for the system under evaluation <NUM>. It is noted that the external agent <NUM> is responsible for defining which features or feature cluster is actually is an issue to be resolved and he or she is also responsible for taking the necessary steps for resolving the issue, after it has been detected.

As mentioned above, the deep encoder <NUM> is a series of stacked encoders, and is responsible to generate features from the data events. The deep encoder layer network of the log analyzer <NUM> transforms input data events from a high-dimensional space into a series of codes into a low-dimensional space containing the information considered to be relevant, the extracted features that are code vectors with relevant information extracted from the data events, as indicated in block <NUM> of the block diagram. In short, the input of the encoder <NUM> may be regarded as a set of points in a multidimensional space, analogous to a nonlinear function that transforms it into data in a lower dimensional code vector. This code vector has most of the relevant information of the input data so as to be able to reconstruct its main features.

Subsequently to the "feature extraction" stage <NUM> mentioned above, there is a Long Short-Term Memory (LSTM) stage <NUM>, which basically serves two main goals on the proposed log analyzer <NUM>:.

The next stage of the block diagram is the "Convolutional Neural Network (CNN)" block <NUM>. The CNN <NUM> uses the features extracted in block <NUM> by the encoding layer <NUM> of the autoencoder <NUM>. This stage of the system is able to consider the expected order in which the features occur, that is, the order is considered along with features, but it is not a rigid parameter. As order is a parameter with a certain degree of flexibility, this enables different order patterns to be identified, adapting also to these new patterns.

Input data is classified by following a series of steps while going through the layers of the CNN <NUM>, namely:.

Block <NUM> indicates the feature clusters. These are clusters of features classified under the same class by the CNN <NUM>. Feature clusters may be further categorized after initial training, under two main groups:.

It is noted that whether a feature is an outside standard one that needs to be evaluated by the external agent <NUM> is defined after the training phase and during production when a new feature is detected.

Further, as the above described embodiment of a log analyzer <NUM> makes use of machine learning techniques to solve the problem, data events stored in a representative random sample of past logs are used for training to create a standard with the expected features and their order.

After the training phase new events are supplied into the system to determine whether their features are contained in the standard. On its output it delivers the potential abnormal events in a comprehensible and concise manner, as outlined above.

As this is a continually reinforced learning system, new events considered within the standard may be used as training events to keep the system updated. Otherwise they are considered as abnormal events and need to be reported and analyzed by an external agent9. This agent <NUM> is responsible to determine whether the event is to be considered an issue or a new acceptable one and reinforced into the system, as mentioned above.

In general, in the initial step, a set of representative random samples of past logs is used to generate the standard set of features, and after relevant information of the logs is comprised in the standard, the system is ready for use. Afterwards, new events are input into the system and compared against the standard and divided into two categories:.

Claim 1:
Computer-implemented method of detecting abnormal events in a telecommunication system (<NUM>), the method comprising a training phase and a production phase, wherein in the training phase, the method comprises the steps of
- recording data events in a log file during the execution of the system (<NUM>);
- creating a standard for the data events representing a properly working environment of the telecommunication system (<NUM>) by applying a training procedure, wherein the properly working environment is characterized by a plurality of features, and a predetermined order of the features, wherein data events stored in a set of representative random samples of the stored log files are used for the training procedure;
and wherein the production phase comprises the steps of
- receiving at least one new data event; and
- determining, whether the at least one new data event is a normal event that matches the standard, and if the at least one new data event matches the standard, using it for updating the standard, and if the at least one new data event does not match the standard, classifying and reporting it as an abnormal event;
- wherein the method further comprises a step of transmitting the at least one event to an autoencoder unit (<NUM>), the autoencoder unit (<NUM>) comprising a deep encoder (<NUM>) and a decoder (<NUM>),
- wherein the deep encoder (<NUM>) transforms the at least one data event from a high-dimensional space into a series of codes in a low-dimensional space, and
- wherein the method further comprises a step of feeding the encoded data events to a Long Short-Term Memory, LSTM (<NUM>).