A deep learning-based server failure prediction system

Abstract

The application belongs to the field of fault prediction, and discloses a server fault prediction system based on deep learning, which comprises a multi-scale time sequence feature extraction module, receives multi-dimensional monitoring index time sequence data of each node of a server cluster, extracts short, medium and long time scale time sequence features through a plurality of parallel causal convolution layers with different expansion rates, a dynamic graph structure learning module, learns an implicit dependency relationship of a node from monitoring data based on an attention mechanism, and generates a synchronously evolving dynamic adjacency matrix, a cross-scale attention fusion module, aligns and fuses different scale time sequence features and dynamic graph structure features by using a cross-attention mechanism, and generates a fusion feature representation, and a fault prediction module, which generates a fault prediction result of each node based on the fusion feature. Compared with the prior art, the system solves the defect that multi-scale time sequence and dynamic graph structure deep coupling cannot be captured simultaneously through multi-module cooperation, and improves the prediction accuracy.

Description

Technical Field

[0001] This invention relates to the field of fault prediction, and more particularly to a server fault prediction system based on deep learning. Background Technology

[0002] Server failure prediction is a crucial technical means to ensure the reliability of data centers and high-performance computing systems. Existing deep learning-based server failure prediction methods mainly fall into three categories: The first category is time-series modeling-based methods, such as CCF-Former, which uses Transformer to capture long-distance dependencies in monitoring indicator sequences. However, these methods treat servers as independent observation objects, ignoring structural dependencies between nodes. The second category is graph neural network-based methods, such as GRAAFE, which models server topology as a graph structure and captures spatial dependencies between nodes through message passing mechanisms. However, this method focuses on static graph modeling and fails to fully integrate the temporal evolution information of node states. The third category is joint time-series and structural modeling methods, such as ISOLATE, which uses a cascaded GNN and GRU to extract relational features and multi-scale temporal features, achieving certain results in identifying microservice performance problems.

[0003] However, the aforementioned existing methods share a common technical drawback: they all employ a separate architecture, first extracting temporal and structural features separately and then performing shallow fusion. This fails to capture both the multi-scale temporal dependencies and dynamically evolving structural dependencies of server monitoring data within a unified end-to-end framework. Server fault evolution inherently exhibits cross-timescale characteristics (second-level jitter, minute-level fluctuations, hour-level degradation) and dynamic structural dependencies (the intensity of influence between nodes and the propagation path change dynamically with the system state). Existing separate architectures lack the ability to model the deep coupling relationship between multi-scale temporal features and dynamic structural features, making it difficult for models to effectively identify complex fault precursor patterns driven by temporal-structural coupling effects, thus limiting prediction accuracy. Summary of the Invention

[0004] The purpose of this invention is to disclose a server fault prediction system based on deep learning, which solves the technical problems mentioned in the background art.

[0005] To achieve the above objectives, the present invention provides the following technical solution: This invention provides a server fault prediction system based on deep learning, comprising: The multi-scale time series feature extraction module is used to receive multi-dimensional monitoring index time series data from each node in the server cluster, and to extract short-scale, medium-scale, and long-scale time series features of the time series data by using multiple parallel causal convolutional layers with different inflation rates. The dynamic graph structure learning module is used to receive the multidimensional monitoring indicator time series data and learn the implicit dependencies between nodes in the server cluster from end to end based on the attention mechanism, and generate a dynamic adjacency matrix that evolves synchronously with the multidimensional monitoring indicator time series data. The cross-scale attention fusion module is used to align and fuse temporal features of different scales with the dynamic graph structure features represented by the dynamic adjacency matrix using a cross-attention mechanism to generate a fused feature representation. The fault prediction module is used to generate fault prediction results for each node in the server cluster based on the fused feature representation.

[0006] Preferably, the server cluster includes a high-performance computing cluster, a cloud computing data center server cluster, or a distributed microservice cluster; The nodes include compute nodes, storage nodes, or management nodes in the server cluster.

[0007] Preferably, the multidimensional monitoring indicator time series data includes time series numerical sequences of multiple performance monitoring indicators of each node in the server cluster, collected according to a preset sampling period; The performance monitoring metrics include at least three of the following: CPU utilization, memory utilization, disk I / O latency, disk read / write throughput, network interface bytes sent / received, process run queue length, temperature sensor readings, and fan speed.

[0008] Preferably, multiple parallel causal convolutional layers with different dilation rates are used to extract short-term, medium-term, and long-term time-series features of the time series data, including: The time series data of the multidimensional monitoring indicators are input in parallel to a first causal convolution branch, a second causal convolution branch, and a third causal convolution branch. Specifically, the first causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a first dilation rate, outputting the short-term temporal features; the second causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a second dilation rate greater than the first dilation rate, outputting the mid-term temporal features; and the third causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a third dilation rate greater than the second dilation rate, outputting the long-term temporal features.

[0009] Preferably, the implicit dependencies between nodes in the server cluster are learned end-to-end from the multidimensional monitoring indicator time series data based on an attention mechanism to generate a dynamic adjacency matrix that evolves synchronously with the multidimensional monitoring indicator time series data, including: The time series data of the multidimensional monitoring indicators are input into the learnable embedding layer to generate the node embedding vector of the node at each time step. For each time step, based on the node embedding vector, the attention weight between any two nodes is calculated through a self-attention mechanism, and the attention weight is used as the implicit dependency strength between the two nodes to generate the adjacency matrix corresponding to that time step. The adjacency matrices corresponding to each time step are arranged in chronological order to form the dynamic adjacency matrix that evolves synchronously with the time series data of the multidimensional monitoring indicators.

[0010] Preferably, the learnable embedding layer is a linear transformation layer. The linear transformation layer receives the multidimensional monitoring indicator time series data as input, maps the multidimensional monitoring indicator time series data to an embedding space of a preset dimension through a trainable weight matrix, and outputs the node embedding vector of each node at each time step.

[0011] Preferably, the attention weights between any two nodes are calculated using a self-attention mechanism, including: For each time step, the node embedding vector of the node is transformed by a first linear transformation to obtain a query vector, and by a second linear transformation to obtain a key vector; Calculate the dot product of the query vector and the key vector between any two nodes, and scale the dot product to obtain the original attention score; The original attention scores are normalized using the softmax function to obtain the attention weights between the two nodes.

[0012] Preferably, the attention weights are used as the implicit dependency strength between two nodes to generate the adjacency matrix corresponding to that time step, including: For each time step, construct an N×N matrix, where N is the number of nodes in the server cluster, and the element in the i-th row and j-th column of the matrix is ​​the attention weight between the i-th node and the j-th node; The matrix is ​​used as the adjacency matrix for that time step, where each element value represents the strength of the implicit dependency between the corresponding two nodes.

[0013] Preferably, a cross-attention mechanism is used to align and fuse temporal features of different scales with the dynamic graph structure features represented by the dynamic adjacency matrix to generate a fused feature representation, including: The system receives the short-scale temporal features, the medium-scale temporal features, and the long-scale temporal features output by the multi-scale temporal feature extraction module, as well as the dynamic adjacency matrix output by the dynamic graph structure learning module. The short-scale time series features, the medium-scale time series features, and the long-scale time series features are concatenated to obtain a multi-scale time series feature sequence, which is then used as the query input for the cross-attention mechanism. The dynamic adjacency matrix is ​​combined with the node embedding vector of each node at the corresponding time step to generate a dynamic graph structure feature sequence, and the dynamic graph structure feature sequence is used as the key input and value input of the cross attention mechanism. The attention-weighted representation between the multi-scale temporal feature sequence and the dynamic graph structure feature sequence is calculated using a cross-attention mechanism, and the fused feature representation is output.

[0014] Preferably, generating fault prediction results for each node in the server cluster based on the fused feature representation includes: The fused feature representation is input into a fully connected layer, and the fully connected layer performs a linear transformation on the fused feature representation to obtain the fault prediction score of each node. The fault prediction score is input into an activation function, which maps the fault prediction score to a probability value of each node failing within a preset time period in the future, and the probability value is used as the fault prediction result of the node.

[0015] Beneficial effects: Compared with existing technologies, this invention effectively addresses the limitation of existing methods in simultaneously capturing the deep coupling relationships between multi-scale temporal features and dynamic graph structure features within an end-to-end framework through the collaborative work of a multi-scale temporal feature extraction module, a dynamic graph structure learning module, and a cross-scale attention fusion module. This enables the identification of temporal-structure coupled fault precursor patterns missed by existing methods, significantly improving fault prediction accuracy. Simultaneously, the dynamic graph structure learning module directly learns implicit dependencies from monitoring data, eliminating the need for static topological prior knowledge and enhancing the system's adaptability to different deployment environments. The parallel causal convolutional branch design ensures the computational efficiency of multi-scale feature extraction, meeting the real-time requirements of online prediction on large-scale server clusters. Attached Figure Description

[0016] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1 This is a schematic diagram of a server fault prediction system based on deep learning according to the present invention.

[0018] Figure 2 This is a schematic diagram illustrating the generation process of the dynamic adjacency matrix of the present invention. Detailed Implementation

[0019] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0020] refer to Figure 1 This invention provides a server fault prediction system based on deep learning, comprising: The multi-scale time series feature extraction module is used to receive multi-dimensional monitoring index time series data from each node in the server cluster, and to extract short-scale, medium-scale, and long-scale time series features of the time series data by using multiple parallel causal convolutional layers with different inflation rates.

[0021] Preferably, the server cluster includes a high-performance computing cluster, a cloud computing data center server cluster, or a distributed microservice cluster.

[0022] The nodes include compute nodes, storage nodes, or management nodes in the server cluster.

[0023] Preferably, the multidimensional monitoring indicator time series data includes time series numerical sequences of multiple performance monitoring indicators of each node in the server cluster, collected according to a preset sampling period; The performance monitoring metrics include at least three of the following: CPU utilization, memory utilization, disk I / O latency, disk read / write throughput, network interface bytes sent / received, process run queue length, temperature sensor readings, and fan speed.

[0024] Preferably, multiple parallel causal convolutional layers with different dilation rates are used to extract short-term, medium-term, and long-term time-series features of the time series data, including: The time series data of the multidimensional monitoring indicators are input in parallel to a first causal convolution branch, a second causal convolution branch, and a third causal convolution branch. Specifically, the first causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a first dilation rate, outputting the short-term temporal features; the second causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a second dilation rate greater than the first dilation rate, outputting the mid-term temporal features; and the third causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a third dilation rate greater than the second dilation rate, outputting the long-term temporal features.

[0025] In one specific implementation, the multi-scale temporal feature extraction module internally has three causal convolutional branches configured in parallel: a first causal convolutional branch, a second causal convolutional branch, and a third causal convolutional branch. The time-series data of multidimensional monitoring indicators from each node in the server cluster are used as input to this module and are simultaneously and in parallel input to the first, second, and third causal convolutional branches.

[0026] The first causal convolutional branch includes at least one first causal convolutional layer, and the dilation rate of the first causal convolutional layer is set to a first dilation rate d1. In a preferred example, the first dilation rate d1 is set to 1, so that the first causal convolutional branch can capture local short-term fluctuation patterns in the time series data of the multidimensional monitoring index with a minimum temporal receptive field, thereby outputting the short-scale time series features characterizing second-level sudden anomalies or high-frequency jitter.

[0027] The second causal convolutional branch includes at least one second causal convolutional layer, and the dilation rate of the second causal convolutional layer is set to a second dilation rate d2 that is greater than the first dilation rate. In a preferred example, the second dilation rate d2 is 2 or 4, so that the second causal convolutional branch has a moderate temporal receptive field, which can effectively model periodic load fluctuations or transition state changes at the minute level, thereby outputting the mid-timescale temporal features.

[0028] The third causal convolutional branch includes at least one third causal convolutional layer, and the dilation rate of the third causal convolutional layer is set to a third dilation rate d3 that is greater than the second dilation rate. In a preferred example, the third dilation rate d3 is 4 or 8 (exponentially increasing with the first and second dilation rates), so that the third causal convolutional branch has the largest temporal receptive field, which can capture the long-term performance degradation trend or slow drift pattern spanning several hours or even several days in the time series data of the multidimensional monitoring index, thereby outputting the long-term time series features.

[0029] The three causal convolutional branches described above can be executed in complete parallelism at the hardware level (such as a graphics processing unit, GPU), without waiting for each other. The short-scale temporal features output by the first causal convolutional branch, the medium-scale temporal features output by the second causal convolutional branch, and the long-scale temporal features output by the third causal convolutional branch are jointly output to the subsequent cross-scale attention fusion module for cross-attention fusion with the dynamic adjacency matrix generated by the dynamic graph structure learning module. Through the above structure, this invention can obtain complete temporal representations covering the short-term, medium-term, and long-term time dimensions in a single operation with low computational latency.

[0030] Through the implementation of the multi-scale temporal feature extraction module described above, this invention decouples and independently models second-level sudden anomalies, minute-level periodic fluctuations, and hourly performance degradation trends in server monitoring data, effectively avoiding the loss of fault precursor information caused by a single temporal receptive field. This provides a temporal feature foundation covering the entire time spectrum for the subsequent cross-scale attention fusion module, enabling the system to capture complex fault precursors driven by the superposition of multiple time scales.

[0031] The dynamic graph structure learning module is used to receive the multidimensional monitoring indicator time series data and learn the implicit dependencies between nodes in the server cluster from end to end based on the multidimensional monitoring indicator time series data, generating a dynamic adjacency matrix that evolves synchronously with the multidimensional monitoring indicator time series data.

[0032] Preferably, such as Figure 2 Based on an attention mechanism, the implicit dependencies between nodes in the server cluster are learned end-to-end from the time-series data of the multidimensional monitoring indicators, generating a dynamic adjacency matrix that evolves synchronously with the time-series data of the multidimensional monitoring indicators, including: The time series data of the multidimensional monitoring indicators are input into the learnable embedding layer to generate the node embedding vector of the node at each time step. For each time step, based on the node embedding vector, the attention weight between any two nodes is calculated through a self-attention mechanism, and the attention weight is used as the implicit dependency strength between the two nodes to generate the adjacency matrix corresponding to that time step. The adjacency matrices corresponding to each time step are arranged in chronological order to form the dynamic adjacency matrix that evolves synchronously with the time series data of the multidimensional monitoring indicators.

[0033] Preferably, the learnable embedding layer is a linear transformation layer. The linear transformation layer receives the multidimensional monitoring indicator time series data as input, maps the multidimensional monitoring indicator time series data to an embedding space of a preset dimension through a trainable weight matrix, and outputs the node embedding vector of each node at each time step.

[0034] In one specific implementation, the learnable embedding layer receives input as the time-series data of the multi-dimensional monitoring metrics for all nodes in the server cluster at each time step. For any given time step, the input is represented as an N×F matrix, where N is the number of nodes and F is the number of performance monitoring metrics included in the time-series data. The learnable embedding layer internally maintains a trainable weight matrix of dimension F×D, where D is a preset embedding space dimension, which can be set to, for example, 64 or 128. By performing matrix multiplication between the N×F input matrix and the F×D trainable weight matrix, the original F-dimensional monitoring metrics are mapped to a D-dimensional embedding space, resulting in an N×D matrix as the output. Each row of this matrix represents the node embedding vector of the corresponding node at that time step. The parameters of the trainable weight matrix are optimized and updated end-to-end during system training using a backpropagation algorithm.

[0035] Preferably, the attention weights between any two nodes are calculated using a self-attention mechanism, including: For each time step, the node embedding vector of the node is transformed by a first linear transformation to obtain a query vector, and by a second linear transformation to obtain a key vector; Calculate the dot product of the query vector and the key vector between any two nodes, and scale the dot product to obtain the original attention score; The original attention scores are normalized using the softmax function to obtain the attention weights between the two nodes.

[0036] Specifically, for a given time step, let the dimension of the node embedding vector be... The preset dimensions of both the query vector and the key vector are The first linear transformation consists of a dimension of The first trainable weight matrix To achieve this, the second linear transformation is implemented using a dimension of... The second trainable weight matrix Implementation. For any node Embed its nodes into vectors (dimension is) )and Multiply to obtain the query vector corresponding to that node.

[0037] Will and Multiplying them together yields the key vector corresponding to that node.

[0038] The first trainable weight matrix and the second trainable weight matrix During system training, end-to-end learning and parameter updates are performed using the backpropagation algorithm.

[0039] Preferably, the attention weights are used as the implicit dependency strength between two nodes to generate the adjacency matrix corresponding to that time step, including: For each time step, construct an N×N matrix, where N is the number of nodes in the server cluster, and the element in the i-th row and j-th column of the matrix is ​​the attention weight between the i-th node and the j-th node; The matrix is ​​used as the adjacency matrix for that time step, where each element value represents the strength of the implicit dependency between the corresponding two nodes.

[0040] In the dynamic graph structure learning module, this invention directly learns the implicit dependencies between nodes end-to-end from the numerical sequence of monitoring indicators, without needing to obtain the physical topology or static configuration information of the server cluster beforehand. The generated dynamic adjacency matrix evolves in real time with the monitoring data, accurately reflecting the dynamic changes in the influence intensity between nodes and the fault propagation path under different system load conditions. This overcomes the problem of lagging structural features caused by existing methods relying on static graph structures, providing accurate and real-time graph structure priors for subsequent deep fusion with multi-scale time-series features.

[0041] The cross-scale attention fusion module is used to align and fuse temporal features of different scales with the dynamic graph structure features represented by the dynamic adjacency matrix using a cross-attention mechanism to generate a fused feature representation.

[0042] Preferably, a cross-attention mechanism is used to align and fuse temporal features of different scales with the dynamic graph structure features represented by the dynamic adjacency matrix to generate a fused feature representation, including: The system receives the short-scale temporal features, the medium-scale temporal features, and the long-scale temporal features output by the multi-scale temporal feature extraction module, as well as the dynamic adjacency matrix output by the dynamic graph structure learning module. The short-scale time series features, the medium-scale time series features, and the long-scale time series features are concatenated to obtain a multi-scale time series feature sequence, which is then used as the query input for the cross-attention mechanism. The dynamic adjacency matrix is ​​combined with the node embedding vector of each node at the corresponding time step to generate a dynamic graph structure feature sequence, and the dynamic graph structure feature sequence is used as the key input and value input of the cross attention mechanism. The attention-weighted representation between the multi-scale temporal feature sequence and the dynamic graph structure feature sequence is calculated using a cross-attention mechanism, and the fused feature representation is output.

[0043] In one specific implementation, the cross-scale attention fusion module receives the short-scale temporal features, the mid-scale temporal features, and the long-scale temporal features output by the multi-scale temporal feature extraction module, as well as the dynamic adjacency matrix output by the dynamic graph structure learning module. The temporal features at these three scales are all multi-dimensional vector sequences, representing the temporal evolution patterns of each node in the server cluster under different temporal receptive fields.

[0044] First, the cross-scale attention fusion module integrates the temporal features. Specifically, for each node in the server cluster, its corresponding short-scale, medium-scale, and long-scale temporal feature vectors are concatenated along the feature dimension direction to form a concatenated feature vector with a dimension equal to the sum of the three dimensions. The concatenated feature vectors of all nodes in the server cluster at each time step are arranged in chronological order to form the multi-scale temporal feature sequence. The cross-scale attention fusion module uses this multi-scale temporal feature sequence as the query input for the cross-attention mechanism.

[0045] Simultaneously, the cross-scale attention fusion module processes the graph structure features. Specifically, for each time step, the dynamic adjacency matrix is ​​an N×N matrix, where matrix elements represent the strength of implicit dependencies between any two nodes; the node embedding vector for each node at that time step is an N×D matrix, where D is the dimension of the node embedding vector. The cross-scale attention fusion module performs matrix multiplication on the dynamic adjacency matrix and the node embedding vector, that is, it uses the dynamic adjacency matrix to perform weighted aggregation on the node embedding vector, so that the feature representation of each node incorporates the information of its implicitly dependent neighboring nodes, thereby generating the dynamic graph structure features for that time step. Arranging the dynamic graph structure features of each time step in chronological order constitutes the dynamic graph structure feature sequence. The cross-scale attention fusion module uses the dynamic graph structure feature sequence as the key and value inputs of the cross-attention mechanism.

[0046] Subsequently, the cross-scale attention fusion module performs cross-attention calculation. The cross-attention mechanism measures the correlation between each feature element in the multi-scale temporal feature sequence and each feature element in the dynamic graph structure feature sequence by calculating the attention weight matrix between the query input and the key input. Then, it uses the attention weight matrix to perform a weighted summation on the value input, enabling the model to adaptively select the graph structure information that best matches the current temporal state from the dynamic graph structure feature sequence based on the correlation between temporal features and graph structure features. This achieves deep alignment and fusion of temporal features and dynamic graph structure features at different scales. The final attention-weighted representation output by the cross-attention mechanism is the fused feature representation, which is sent to the fault prediction module for subsequent fault probability prediction.

[0047] The module described in this invention utilizes a cross-attention mechanism to establish end-to-end attention alignment between multi-scale temporal feature sequences and dynamic graph structure feature sequences, achieving deep coupling modeling of temporal evolution patterns and structural dependencies. Unlike the simple feature splicing or weighted fusion methods in existing technologies, this mechanism allows the model to adaptively filter the most relevant graph structure information based on the current temporal state, thereby effectively capturing fault precursor patterns driven by temporal-structural coupling effects.

[0048] The fault prediction module is used to generate fault prediction results for each node in the server cluster based on the fused feature representation.

[0049] Preferably, generating fault prediction results for each node in the server cluster based on the fused feature representation includes: The fused feature representation is input into a fully connected layer, and the fully connected layer performs a linear transformation on the fused feature representation to obtain the fault prediction score of each node. The fault prediction score is input into an activation function, which maps the fault prediction score to a probability value of each node failing within a preset time period in the future, and the probability value is used as the fault prediction result of the node.

[0050] In one specific implementation, the fault prediction module receives the fused feature representation output by the cross-scale attention fusion module. This fused feature representation is a multi-dimensional vector sequence, where the vector at each time step corresponds to the comprehensive state representation of each node in the server cluster at the current time step. First, the fault prediction module inputs the fused feature representation into a fully connected layer. The fully connected layer consists of a trainable weight matrix and a trainable bias vector. Specifically, let the dimension of the feature corresponding to each node in the fused feature representation be H, and the output dimension of the fully connected layer be 1. For any node i, the fully connected layer... A linear transformation is performed to calculate the fault prediction score for that node. ,in For the trainable weight matrix, The bias vector. The fault prediction score. The score is a real scalar, and its magnitude reflects the tendency of node i to fail in its current state; a higher score indicates a greater likelihood of failure. The failure prediction module then inputs the failure prediction score into the activation function. In a preferred example, the activation function is the Sigmoid function, whose mathematical expression is: The Sigmoid function will score the fault prediction. Map to the (0,1) interval and output a probability value. This probability value This represents the predicted probability that node i will fail within the preset future time period. The preset future time period can be configured according to actual operation and maintenance needs, for example, set to 1 hour, 6 hours, or 24 hours, indicating that the system will predict whether the node will fail within that time period. Finally, the fault prediction module outputs the probability value as the fault prediction result for the node. In practical applications, operation and maintenance personnel can set an early warning threshold (e.g., 0.5 or 0.7) based on the fault prediction probability. When the predicted probability of a node exceeds this threshold, an alarm is triggered so that preventative fault prevention measures can be taken in advance.

[0051] The fault prediction module of this invention maps the deeply fused feature representation into intuitive fault probability values, providing quantifiable decision-making basis for operations and maintenance personnel. The combined design of fully connected layers and activation functions enables the model to output deterministic risk indicators for each node within a preset future time period while maintaining high-precision prediction capabilities. Combining the aforementioned joint modeling capabilities of multi-scale temporal series and dynamic graph structures, this invention comprehensively overcomes the accuracy bottleneck of existing methods in server fault prediction scenarios.

[0052] The preferred embodiments of the present invention disclosed above are merely illustrative of the invention. These preferred embodiments do not exhaustively describe all details, nor do they limit the invention to the specific implementations described. Clearly, many modifications and variations can be made based on the content of this specification. This specification selects and specifically describes these embodiments to better explain the principles and practical applications of the invention, thereby enabling those skilled in the art to better understand and utilize the invention. The invention is limited only by the claims and their full scope and equivalents.

Claims

1. A server fault prediction system based on deep learning, characterized in that, include: The multi-scale time series feature extraction module is used to receive multi-dimensional monitoring index time series data from each node in the server cluster, and to extract short-scale, medium-scale, and long-scale time series features of the time series data by using multiple parallel causal convolutional layers with different inflation rates. The dynamic graph structure learning module is used to receive the multidimensional monitoring indicator time series data and learn the implicit dependencies between nodes in the server cluster from end to end based on the attention mechanism, and generate a dynamic adjacency matrix that evolves synchronously with the multidimensional monitoring indicator time series data. The cross-scale attention fusion module is used to align and fuse temporal features of different scales with the dynamic graph structure features represented by the dynamic adjacency matrix using a cross-attention mechanism to generate a fused feature representation. The fault prediction module is used to generate fault prediction results for each node in the server cluster based on the fused feature representation.

2. The server fault prediction system based on deep learning according to claim 1, characterized in that, The server cluster includes a high-performance computing cluster, a cloud computing data center server cluster, or a distributed microservice cluster. The nodes include compute nodes, storage nodes, or management nodes in the server cluster.

3. A server fault prediction system based on deep learning according to claim 1 or 2, characterized in that, The multidimensional monitoring indicator time series data includes time-series numerical sequences of multiple performance monitoring indicators of each node in the server cluster, collected according to a preset sampling period. The performance monitoring metrics include at least three of the following: CPU utilization, memory utilization, disk I / O latency, disk read / write throughput, network interface bytes sent / received, process run queue length, temperature sensor readings, and fan speed.

4. The server fault prediction system based on deep learning according to claim 1, characterized in that, Multiple parallel causal convolutional layers with different dilation rates are used to extract short-term, medium-term, and long-term time-series features of the time series data, including: The time series data of the multidimensional monitoring indicators are input in parallel to a first causal convolution branch, a second causal convolution branch, and a third causal convolution branch. Specifically, the first causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a first dilation rate, outputting the short-term temporal features; the second causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a second dilation rate greater than the first dilation rate, outputting the mid-term temporal features; and the third causal convolution branch performs a causal convolution operation on the time series data of the multidimensional monitoring indicators using a third dilation rate greater than the second dilation rate, outputting the long-term temporal features.

5. The server fault prediction system based on deep learning according to claim 1, characterized in that, Based on an attention mechanism, the implicit dependencies between nodes in the server cluster are learned end-to-end from the time-series data of the multidimensional monitoring indicators, generating a dynamic adjacency matrix that evolves synchronously with the time-series data of the multidimensional monitoring indicators, including: The time series data of the multidimensional monitoring indicators are input into the learnable embedding layer to generate the node embedding vector of the node at each time step. For each time step, based on the node embedding vector, the attention weight between any two nodes is calculated through a self-attention mechanism, and the attention weight is used as the implicit dependency strength between the two nodes to generate the adjacency matrix corresponding to that time step. The adjacency matrices corresponding to each time step are arranged in chronological order to form the dynamic adjacency matrix that evolves synchronously with the time series data of the multidimensional monitoring indicators.

6. The server fault prediction system based on deep learning according to claim 5, characterized in that, The learnable embedding layer is a linear transformation layer. The linear transformation layer receives the multidimensional monitoring indicator time series data as input, maps the multidimensional monitoring indicator time series data to an embedding space of a preset dimension through a trainable weight matrix, and outputs the node embedding vector of each node at each time step.

7. A server fault prediction system based on deep learning according to claim 5, characterized in that, The attention weights between any two nodes are calculated using a self-attention mechanism, including: For each time step, the node embedding vector of the node is transformed by a first linear transformation to obtain a query vector, and by a second linear transformation to obtain a key vector; Calculate the dot product of the query vector and the key vector between any two nodes, and scale the dot product to obtain the original attention score; The original attention scores are normalized using the softmax function to obtain the attention weights between the two nodes.

8. A server fault prediction system based on deep learning according to claim 5, characterized in that, Using the attention weights as the implicit dependency strength between two nodes, the adjacency matrix corresponding to this time step is generated, including: For each time step, construct an N×N matrix, where N is the number of nodes in the server cluster, and the element in the i-th row and j-th column of the matrix is ​​the attention weight between the i-th node and the j-th node; The matrix is ​​used as the adjacency matrix for that time step, where each element value represents the strength of the implicit dependency between the corresponding two nodes.

9. A server fault prediction system based on deep learning according to claim 1, characterized in that, A cross-attention mechanism is employed to align and fuse temporal features at different scales with the dynamic graph structure features represented by the dynamic adjacency matrix, generating a fused feature representation, including: The system receives the short-scale temporal features, the medium-scale temporal features, and the long-scale temporal features output by the multi-scale temporal feature extraction module, as well as the dynamic adjacency matrix output by the dynamic graph structure learning module. The short-scale time series features, the medium-scale time series features, and the long-scale time series features are concatenated to obtain a multi-scale time series feature sequence, which is then used as the query input for the cross-attention mechanism. The dynamic adjacency matrix is ​​combined with the node embedding vector of each node at the corresponding time step to generate a dynamic graph structure feature sequence, and the dynamic graph structure feature sequence is used as the key input and value input of the cross attention mechanism. The attention-weighted representation between the multi-scale temporal feature sequence and the dynamic graph structure feature sequence is calculated using a cross-attention mechanism, and the fused feature representation is output.

10. A server fault prediction system based on deep learning according to claim 1, characterized in that, Based on the fusion feature representation, fault prediction results are generated for each node in the server cluster, including: The fused feature representation is input into a fully connected layer, and the fully connected layer performs a linear transformation on the fused feature representation to obtain the fault prediction score of each node. The fault prediction score is input into an activation function, which maps the fault prediction score to the probability value of each node failing within a preset time period in the future, and the probability value is used as the fault prediction result of the node.

Images