Spine-Leaf network hidden fault detection method based on deep learning

Abstract

The invention discloses a Spine-Leaf network hidden fault detection method based on deep learning, and the method comprises the steps: collecting the structure information of a Spine-Leaf network and the time sequence state data (TX, RTT and Qlen) of an RDMA network card, analyzing the feature rule of the time sequence state data of the RDMA network card when hidden faults exist, building a feature encoder based on LSTM and CNN dual-branch fusion and a classification network based on a softmax function, and carrying out the detection of the hidden faults of the Spine-Leaf network. And then training model parameters by using a cross entropy loss function in an offline training stage, and finally outputting a probability that a communication path has a hidden fault based on real-time state data of the terminal RDMA network card in an online evaluation stage. The method can effectively solve the problems that Spine-Leaf network hidden fault feature capture is not comprehensive and detection is not sensitive, hidden fault recognition accuracy and real-time performance are improved to the maximum extent, and efficiency loss of a distributed deep learning task caused by network abnormity is reduced.

Description

Technical Field

[0001] This invention belongs to the field of computer network fault detection technology, specifically involving a non-display alarm fault detection technology for Spine-Leaf network RDMA communication based on a deep learning model, and particularly involving real-time detection of non-display alarm faults in Spine-Leaf network RDMA communication by monitoring changes in key network status parameters of the server-side RDMA network card. Background Technology

[0002] In Spine-Leaf architecture data center networks, Remote Direct Memory Access (RDMA) technology, with its zero-copy, low-latency, and high-bandwidth characteristics, has become a core technology supporting efficient communication in scenarios such as distributed deep learning and high-performance computing. [1] .

[0003] In practical operation, Spine-Leaf networks are susceptible to factors such as link fluctuations, buffer congestion, and hardware aging, resulting in non-obvious alarm faults that cause abnormal RDMA communication performance without triggering explicit device alarms. These faults manifest as periodic fluctuations in throughput and abnormal accumulation of round-trip delays, but neither the switch nor the RDMA network card outputs alarm logs. Traditional threshold-based monitoring methods struggle to identify them. Severe faults can slow down distributed training, reduce cluster resource utilization, and even cause task interruptions. Traditional threshold detection methods can only identify explicit faults and are insensitive to non-obvious alarm faults without obvious threshold breakthroughs. Existing deep learning models are not specifically adapted to the temporal state parameters of RDMA network cards, resulting in insufficient feature extraction capabilities. Therefore, to ensure the stable operation of Spine-Leaf networks using RDMA technology in high-performance scenarios such as distributed deep learning, there is an urgent need for a deep learning solution that can accurately capture the local and long-term temporal features of RDMA network card state parameters by monitoring the temporal state parameters of the server-side RDMA network card, thereby achieving real-time and efficient detection of non-obvious alarm faults. Summary of the Invention

[0004] To address the aforementioned technical issues, this invention provides a deep learning-based method for detecting non-display alarm faults in Spine-Leaf networks. By accurately capturing local correlation features and long-term temporal dependency features in the monitored RDMA network card time-series network status data, it provides a real-time detection method for non-display alarm faults in Spine-Leaf networks, thereby effectively improving the identification accuracy and detection sensitivity of non-display alarm faults and reducing efficiency losses caused by network anomalies in high-performance tasks such as distributed deep learning.

[0005] The technical solution adopted in this invention is: a non-display alarm fault detection method for Spine-Leaf networks based on deep learning models, the specific steps of which are as follows: Step 1: Collect the structure of the Spine-Leaf network and the network state variables of the RDMA network card, obtain the number of GPU nodes, Spine switches and node / switch connection relationships, and analyze the characteristic patterns of the RDMA network card network state variables by combining network logs and historical fault records to complete the selection of the core deep learning network for the fault detection model. Step 2: Construct a fault detection model, using a feature encoder built on Long Short-Term Memory (LSTM) and Convolutional Neural Network (CNN). [2,3] Based on the softmax function, a classification network is established to evaluate the key network state variables and classification probability values ​​of RDMA network cards; Step 3: In the offline training phase, the training dataset is collected through interaction with the simulation environment. Cross-entropy is used as the loss function to train the fault detection model and optimize the network parameters of the fault detection model. Step 4: In the online decision-making stage, obtain the real-time network state variable time series data of the server-side RDMA network card in the Spine-Leaf network, and call the trained fault detection model for output; Furthermore, step 2 is detailed below: The core architecture for building the fault detection model consists of a feature encoder based on LSTM and CNN, and a classification network based on the softmax function. The specific architecture and functional definitions of the feature encoder and classification network are as follows: (a) Architecture and function of the feature encoder: The feature encoder adopts a fusion structure of CNN and LSTM, through dual... The branch parallel processing of raw monitoring data enables the collaborative extraction of local and temporal features, specifically including: The CNN branch contains three cascaded Conv1D modules. Each Conv1D module consists of a one-dimensional CNN unit, a batch normalization unit, and a LeakReLU activation function. The LeakReLU activation function is defined as shown in equation (1). (1) In the formula, x is the input of the LeakReLU unit. The coefficients are negative (used to adjust the weights of negative features). After processing by three Conv1D modules, the first convolutional feature vector is output. The CNN branch has a residual connection structure, specifically: the first convolutional features are processed by another independently configured Conv1D module. Dimension adaptation is performed to obtain second convolutional features that match the dimensions of the main path features. The first convolutional feature With the second convolution feature The features are added element-wise using an addition operator to generate fused residual features. Regarding the aforementioned Applying average pooling compresses the feature space through downsampling, resulting in a pooling result with regular dimensions. .

[0006] The LSTM-based attention network branch contains three independently configured LSTM function modules, denoted as follows: , , All three methods use the original monitoring data X as input and generate query matrices through time-series feature encoding. Key matrix Value matrix Their mathematical expressions are shown in equations (2), (3), and (4), respectively: (2) (3) (4) Subsequently, the above query matrix Key matrix Value matrix The input is fed into the attention computation structure, and temporal feature vectors are generated through matrix multiplication: First, calculate... and transpose matrix The product of these two elements is then activated by the softmax function. The normalized weights are obtained through processing, and finally, these weights are compared with the value matrix. Perform weighted summation to output time series feature vectors Its mathematical expression is (5) Will As mentioned above Perform concatenation to generate a dimension of The fused feature vector F.

[0007] (b) The classification network takes the fused feature vector F as input, and its core function is to classify and identify the network state. The specific processing flow is as follows: The first layer of the classification network is a dropout layer, which randomly deactivates the input fused feature vector F (by masking some neuron connections with a preset deactivation probability) and outputs a regularized feature vector. ; The fully connected layers of the classification network regularize the feature vectors. The high-dimensional feature space is mapped to a preset state category space, wherein the state category space includes the normal operation state of the network and at least two preset latent fault types, forming an original output vector whose dimension matches the total number of categories; The original output vector is processed by applying a softmax activation function, and the class probability distribution is obtained through normalization. in, This represents the probability value that the current input sample belongs to the j-th class state (satisfying...). k is the preset total number of state categories, and the category probability distribution P is the output result of the classification network, providing a quantitative decision basis for the classification and recognition of network states; Furthermore, step 3 is detailed below: During the offline training phase, the fault detection model collects training datasets (including raw monitoring data of RDMA network cards and corresponding real-state labels) through interaction with the simulator. It then updates the parameters of the feature encoder and classification network using an end-to-end collaborative training mode. Both share the same cross-entropy loss function as the objective function for parameter optimization. The cross-entropy loss function is defined as follows: (6) in, The set of network parameters to be optimized (including parameters from the feature encoder) With the parameters of the classification network E is the expectation function, N is the number of training samples, and k is the total number of state categories; Let i be the true label of the i-th sample. The corresponding predicted probabilities are output by the classification network; during training, the total loss is adjusted using the RMSProp optimizer. Perform backpropagation to synchronously update the parameters of the feature encoder and the classification network, enabling the feature encoder to learn more effective features suitable for the classification task, while optimizing the decision boundary of the classification network; repeat the above process of interactive data acquisition and parameter update with the simulation environment until the cross-entropy loss is reached. Once the training converges to below the preset threshold or reaches the maximum number of training iterations, the offline training phase is terminated and the process proceeds to step 4.

[0008] Furthermore, step 4 is detailed below: The trained fault detection model is invoked to perform real-time online detection and judgment of the time-series data of key network state variables of the server-side RDMA network card in the Spine-Leaf network, as detailed below: Step 41: During the online testing phase, key network status variables of the server-side RDMA network card are collected in real time, including but not limited to... Real-time monitoring data sequences are generated from time-series parameters such as real-time throughput (tx), queue length (qlen), and packet latency (rtt). ; Step 42: Process the real-time monitoring data sequence Preprocessing (including format standardization, numerical normalization, and processing methods) is performed. (The formula is consistent with the offline training stage), resulting in feature vectors that meet the model input requirements. ; Step 43: Transfer the preprocessed feature vectors Input to the trained fault detection model (including feature encoder and classification network): Feature encoder (LSTM and CNN fusion architecture) Perform feature encoding and output a fused feature vector. ; Classification network pairs Process the data and output the class probability distribution. ,in This represents the real-time probability that the current network interface card (NIC) status belongs to the j-th category. Step 44: Select the category probability distribution The category corresponding to the highest probability value is taken as the detection result, i.e.: result = argmax( ), where result is the final output state judgment; Step 45: Feed the detection results back to the Spine-Leaf network operation and maintenance system in real time. If the system is determined to be in a fault state, trigger the corresponding alarm or fault handling process simultaneously. At the same time, continue to collect the RDMA network card status data for the next time period and repeat steps 41-44 until the monitoring task is terminated.

[0009] The beneficial effects of this invention are as follows: The method of this invention first collects the temporal state parameters (throughput tx, queue length qlen, packet delay rtt, etc.) of the RDMA network card on the server side in the Spine-Leaf network, and analyzes the characteristics of the RDMA network card's temporal state parameters; based on the analysis results, a dual-branch feature encoder integrating CNN and LSTM attention networks is constructed. The CNN branch extracts local correlation features, and the LSTM attention branch captures long temporal dependency features. The features are then concatenated to generate a fused feature vector; then, the state category probability distribution is output by a classification network containing dropout and softmax layers to form a fault detection model; then, during the offline training stage, the cross-entropy loss function is used to collaboratively update the feature encoder and classification network parameters end-to-end; finally, during the online detection stage, the classification detection results are output based on real-time monitoring of network state data. The method of this invention can effectively solve the problems of incomplete capture of latent fault features and insufficient detection sensitivity of existing technologies in Spine-Leaf networks. It can accurately identify performance degradation faults without explicit alarms, significantly improve the accuracy and real-time performance of latent fault detection, provide reliable guarantee for the stable operation of Spine-Leaf networks in high-performance scenarios such as distributed deep learning, and reduce the loss of task efficiency caused by network anomalies. Attached Figure Description

[0010] Figure 1 This is an overall flowchart of a method for detecting latent faults in Spine-Leaf networks based on deep learning models, according to the present invention.

[0011] Figure 2 This is a schematic diagram of a Spine-Leaf network example in an embodiment of the present invention.

[0012] Figure 3 This is a structural diagram of a hidden fault detection method based on a deep learning model using a Spine-Leaf network according to the present invention.

[0013] Figure 4 This is a schematic diagram illustrating a scenario with a latent fault in an embodiment of the present invention. Detailed Implementation

[0014] The technical solution of the invention will be further described below with reference to the accompanying drawings and embodiments.

[0015] like Figure 1 The flowchart of a latent fault detection method for Spine-Leaf networks based on a deep learning model, as shown in the figure, includes the following specific steps: Step 1: Collect the structure of the Spine-Leaf network and the network state variables of the RDMA network card, obtain the number of GPU nodes, Spine switches and node / switch connection relationships, and analyze the characteristic patterns of the RDMA network card network state variables in combination with network logs and historical fault records to preliminarily evaluate which deep learning network to use as the core component of the fault detection model. Step 2: Construct a fault detection model. Based on LSTM and CNN neural networks, construct a feature encoder. Based on the softmax function, establish a classification network to evaluate the key network state variables and classification probability values ​​of the RDMA network card. Step 3: In the offline training phase, the training dataset is collected through interaction with the simulation environment. Cross-entropy is used as the loss function to train the fault detection model and optimize the network parameters of the fault detection model. Step 4: In the online decision-making stage, obtain the real-time network state variable time series data of the server-side RDMA network card in the Spine-Leaf network, and call the trained fault detection model for output; In this embodiment, step 1 is specifically as follows: As shown in Figure 2, this embodiment uses a typical Spine-Leaf network test environment. The network includes 16 Server nodes, 8 Leaf switches, and 4 Spine switches. Each Server is configured with 2 RDMA network cards supporting the RoCEv2 protocol (including 1 spare network card). The communication bandwidth of the links between switches is 800Gbps, and the communication bandwidth of the links between Servers and switches is 250Gbps.

[0016] Infrastructure information was collected using network topology discovery tools: there were 16 GPU nodes, 4 Spine switches, and 8 Leaf switches, with all GPU nodes interconnected via a Spine-Leaf architecture. Simultaneously, monitoring tools were deployed on the server side to collect real-time network status variables of the RDMA network cards, specifically including: throughput (TX, in Gbps), queue length (Qlen, in packets), and round-trip latency (RTT, in µs). The sampling frequency was set to the minimum RTT value in the Spine-Leaf network, and the collection duration covered the complete communication cycle of an ALLREDUCE primitive during a deep learning distributed training task (the total communication volume of a single ALLREDUCE is 655360 bytes). Finally, time-series data of the RDMA network card status variables from the 16 servers were collected, with a total length of 5278 records.

[0017] Combining network operation and maintenance logs and historical fault records, the characteristic patterns of RDMA network card state variables were analyzed: when a latent fault occurs, TX exhibits periodic fluctuations (fluctuation amplitude ≥ 40%), Qlen oscillates at high frequency within the latent fault outbreak time window, and RTT increases by 20%-40% compared to the normal state (without explicit alarm triggering). Based on the above characteristics, a preliminary assessment was made: due to the strong temporal dependence of the data (manifested as the cumulative trend of RTT delay) and local correlation (manifested as the coupled fluctuations of TX and Qlen), a dual-branch network integrating LSTM and CNN was determined to be used as the core component of the feature encoder in the fault detection model.

[0018] In this embodiment, step 2 is specifically as follows: like Figure 3 The diagram shows the structure of a hidden fault detection method based on a deep learning model using a Spine-Leaf network according to the present invention. The specific structure is as follows: The core architecture of the fault detection method consists of a feature encoder and a classification network: (a) The feature encoder adopts a fusion structure of CNN and LSTM, specifically including: The CNN branch contains three cascaded Conv1D modules. Each Conv1D module consists of a one-dimensional CNN unit, a batch normalization unit, and a LeakReLU activation function. The LeakReLU activation function is defined as shown in equation (1). (1) In the formula, x is the input of the LeakReLU unit. The coefficients are negative (used to adjust the weights of negative features). After processing by three Conv1D modules, the first convolutional feature vector is output. In this embodiment, the default number of filters in the three cascaded Conv1D modules are 256, 256, and 128, respectively, and the convolutional kernel sizes are 8, 5, and 3. The CNN branch incorporates a residual connection structure, specifically: the first convolutional features are processed by another independently configured Conv1D module. Dimension adaptation is performed to obtain second convolutional features that match the dimensions of the main path features. The first convolutional feature With the second convolution feature The features are added element-wise using an addition operator to generate fused residual features. Regarding the aforementioned Applying average pooling compresses the feature space through downsampling, resulting in a pooling result with regular dimensions. .

[0019] The LSTM-based attention network branch contains three independently configured LSTM function modules, denoted as follows: , , All three methods use the original monitoring data X as input. In this embodiment, the number of hidden units in each LSTM network is set to 128, and query matrices are generated through temporal feature encoding. Key matrix Value matrix Their mathematical expressions are shown in equations (2), (3), and (4), respectively: (2) (3) (4) Subsequently, the above query matrix Key matrix Value matrix The input is fed into the attention computation structure, and temporal feature vectors are generated through matrix multiplication: First, calculate... and transpose matrix The product of these two elements is then activated by the softmax function. The normalized weights are obtained through processing, and finally, these weights are compared with the value matrix. Perform weighted summation to output time series feature vectors Its mathematical expression is (5) Will As mentioned above Perform concatenation to generate a dimension of The fused feature vector F.

[0020] (b) The classification network takes the fused feature vector F as input, and its core function is to classify and identify the network state. The specific processing flow is as follows: The first layer of the classification network is a dropout layer, which randomly deactivates the input fused feature vector F (by masking some neuron connections with a preset deactivation probability) and outputs a regularized feature vector. ; The fully connected layers of the classification network regularize the feature vectors. The high-dimensional feature space is mapped to a preset state category space, wherein the state category space includes the normal operation state of the network and at least two preset latent fault types, forming an original output vector whose dimension matches the total number of categories; The original output vector is processed by applying a softmax activation function, and the class probability distribution is obtained through normalization. in, This represents the probability value that the current input sample belongs to the j-th class state (satisfying...). k is the preset total number of state categories, and the category probability distribution P is the output result of the classification network, providing a quantitative decision basis for the classification and recognition of network states; In this embodiment, step 3 is specifically as follows: During the offline training phase, the fault detection model collects training datasets (including raw monitoring data of the RDMA network card and corresponding real-state labels) through interaction with the simulation environment. It then updates the parameters of the feature encoder and classification network using an end-to-end collaborative training mode. Both share the same cross-entropy loss function as the objective function for parameter optimization. The cross-entropy loss function is defined as follows: (6) in, The set of network parameters to be optimized (including parameters from the feature encoder) With the parameters of the classification network E is the expectation function, N is the number of training samples, and k is the total number of state categories; Let i be the true label of the i-th sample. The corresponding predicted probabilities are output by the classification network; during training, the total loss is adjusted using the RMSProp optimizer. Perform backpropagation to synchronously update the parameters of the feature encoder and the classification network, enabling the feature encoder to learn more effective features suitable for the classification task, while optimizing the decision boundary of the classification network; repeat the above process of interactive data acquisition and parameter update with the simulation environment until the cross-entropy loss is reached. Once the training converges to below the preset threshold or reaches the maximum number of training iterations, the offline training phase is terminated and the process proceeds to step 4.

[0021] In this embodiment, the hyperparameters for training the fault detection model are set as follows: the learning rate lrate = 0.01 for the LSTM-based attention network branch in the feature encoder; the maximum number of training iterations: 500; and the dropout rate of the Dropout layer in the classification network is set to 0.2.

[0022] In this embodiment, step 4 is specifically as follows: Step 41: During the online testing phase, key network status variables of the server-side RDMA network card are collected in real time, including but not limited to... Real-time monitoring data sequences are generated from time-series parameters such as real-time throughput (tx), queue length (qlen), and packet latency (rtt). ; Step 42: Process the real-time monitoring data sequence Preprocessing (including format standardization, numerical normalization, and processing methods) is performed. (The formula is consistent with the offline training stage), resulting in feature vectors that meet the model input requirements. ; Step 43: Transfer the preprocessed feature vectors Input to the trained fault detection model (including feature encoder and classification network): Feature encoder (LSTM and CNN fusion architecture) Perform feature encoding and output a fused feature vector. ; Classification network pairs Process the data and output the class probability distribution. ,in This represents the real-time probability that the current network interface card (NIC) status belongs to the j-th category. Step 44: Select the category probability distribution The category corresponding to the highest probability value is taken as the detection result, i.e.: result = argmax( ), where result is the final output state judgment; Step 45: Feed the detection results back to the Spine-Leaf network operation and maintenance system in real time. If the system is determined to be in a fault state, trigger the corresponding alarm or fault handling process simultaneously. At the same time, continue to collect the RDMA network card status data for the next time period and repeat steps 41-44 until the monitoring task is terminated.

[0023] In this embodiment, a detection scenario for a certain latent fault is as follows: Figure 4 As shown, when a latent fault occurs in link L-1 to S-1 in the Spine-Leaf network, the shortest time from the occurrence of the fault to the completion of detection and triggering of alarm by the fault detection method deployed on each server is only 25us; at the same time, for communication paths in the network that are in normal condition, the detection method does not produce false alarms, and the false alarm rate in this scenario is 0.

[0024] In summary, the method of this invention can effectively solve the problems of incomplete capture of latent fault features and insufficient detection sensitivity in Spine-Leaf networks, significantly improve the accuracy and real-time performance of fault identification in scenarios without explicit alarms, and maximize the stable operation of high-performance tasks such as distributed deep learning.

[0025] The above description is merely an embodiment of the present invention and is not intended to limit the invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principle of the present invention should be included within the scope of the claims of the present invention.

Claims

1. A method for detecting latent faults in Spine-Leaf networks based on deep learning, the specific steps of which are as follows: Step 1: Collect the structure of the Spine-Leaf network and the network state variables of the RDMA network card, obtain the number of GPU nodes, Spine switches and node / switch connection relationships, and analyze the characteristic patterns of the RDMA network card network state variables in combination with network logs and historical fault records to preliminarily evaluate which deep learning network to use as the core component of the fault detection model. Step 2: Construct a fault detection model. Based on LSTM and CNN neural networks, construct a feature encoder. Based on the softmax function, establish a classification network to evaluate the key network state variables and classification probability values ​​of the RDMA network card. Step 3: In the offline training phase, the training dataset is collected through interaction with the simulation environment. Cross-entropy is used as the loss function to train the fault detection model and optimize the network parameters of the fault detection model. Step 4: In the online decision-making stage, obtain the real-time network state variable time series data of the server-side RDMA network card in the Spine-Leaf network, and call the trained fault detection model for output.

2. The method for detecting latent faults in Spine-Leaf networks based on deep learning as described in claim 1. Its features are, Step 2 is described in detail below: The core architecture for building the fault detection model consists of a feature encoder based on LSTM and CNN, and a classification network based on the softmax function. The specific architecture and functional definitions of the feature encoder and classification network are as follows: (a) Architecture and function of the feature encoder: The feature encoder adopts a fusion structure of CNN and LSTM, through dual... The branch parallel processing of raw monitoring data enables the collaborative extraction of local and temporal features, specifically including: The CNN branch contains three cascaded Conv1D modules. Each Conv1D module consists of a one-dimensional CNN unit, a batch normalization unit, and a LeakReLU activation function. The LeakReLU activation function is defined as shown in equation (1). (1) In the formula, x is the input of the LeakReLU unit. The coefficients with negative values ​​(used to adjust the weights of negative features) are processed by three Conv1D modules to output the first convolutional feature vector. The CNN branch has a residual connection structure, specifically: the first convolutional features are processed by another independently configured Conv1D module. Dimension adaptation is performed to obtain second convolutional features that match the dimensions of the main path features. The first convolutional feature With the second convolution feature The features are added element-wise using an addition operator to generate fused residual features. Regarding the aforementioned Applying average pooling compresses the feature space through downsampling, resulting in a pooling result with regular dimensions. , The LSTM-based attention network branch contains three independently configured LSTM function modules, denoted as follows: , , All three methods use the original monitoring data X as input and generate query matrices through time-series feature encoding. Key matrix Value matrix Their mathematical expressions are shown in equations (2), (3), and (4), respectively: (2) (3) (4) Subsequently, the above query matrix Key matrix Value matrix The input is fed into the attention computation structure, and temporal feature vectors are generated through matrix multiplication: First, calculate... and transpose matrix The product of these two elements is then activated by the softmax function. The normalized weights are obtained through processing, and finally, these weights are compared with the value matrix. Perform weighted summation to output time series feature vectors Its mathematical expression is (5) Will As mentioned above Perform concatenation to generate a dimension of The fused feature vector F, (b) The classification network takes the fused feature vector F as input, and its core function is to classify and identify the network state. The specific processing flow is as follows: The first layer of the classification network is a dropout layer, which randomly deactivates the input fused feature vector F (by masking some neuron connections with a preset deactivation probability) and outputs a regularized feature vector. ; The fully connected layers of the classification network regularize the feature vectors. The high-dimensional feature space is mapped to a preset state category space, wherein the state category space includes the normal operation state of the network and at least two preset latent fault types, forming an original output vector whose dimension matches the total number of categories; The original output vector is processed by applying a softmax activation function, and the class probability distribution is obtained through normalization. in, This represents the probability value that the current input sample belongs to the j-th class state (satisfying...). k is the preset total number of state categories, and the category probability distribution P is the output result of the classification network, providing a quantitative decision basis for the classification and recognition of network states.

3. The method for detecting latent faults in Spine-Leaf networks based on deep learning according to claim 1, characterized in that, Step 3 is as follows: During the offline training phase, the fault detection model collects training datasets (including raw monitoring data of RDMA network cards and corresponding real-state labels) through interaction with the simulator. It then updates the parameters of the feature encoder and classification network using an end-to-end collaborative training mode. Both share the same cross-entropy loss function as the objective function for parameter optimization. The cross-entropy loss function is defined as follows: (6) in, The set of network parameters to be optimized (including parameters from the feature encoder) With the parameters of the classification network E is the expectation function, N is the number of training samples, and k is the total number of state categories; Let i be the true label of the i-th sample. The corresponding predicted probabilities are output by the classification network; during training, the total loss is adjusted using the RMSProp optimizer. Perform backpropagation to synchronously update the parameters of the feature encoder and the classification network, enabling the feature encoder to learn more effective features suitable for the classification task, while optimizing the decision boundary of the classification network; repeat the above process of interactive data acquisition and parameter update with the simulation environment until the cross-entropy loss is reached. Once the training converges to below the preset threshold or reaches the maximum number of training iterations, the offline training phase is terminated and the process proceeds to step 4.

4. The method for detecting latent faults in Spine-Leaf networks based on deep learning according to claim 1, characterized in that, Step 4 is described in detail below: The trained fault detection model is invoked to perform real-time online detection and judgment of the time-series data of key network state variables of the server-side RDMA network card in the Spine-Leaf network, as detailed below: Step 41: During the online testing phase, key network status variables of the server-side RDMA network card are collected in real time, including but not limited to... Real-time monitoring data sequences are generated from time-series parameters such as real-time throughput (tx), queue length (qlen), and packet latency (rtt). ; Step 42: Process the real-time monitoring data sequence Preprocessing (including format standardization, numerical normalization, and processing methods) is performed. (The formula is consistent with the offline training stage), resulting in feature vectors that meet the model input requirements. ; Step 43: Transfer the preprocessed feature vectors Input to the trained fault detection model (including feature encoder and classification network): Feature encoder (LSTM and CNN fusion architecture) Perform feature encoding and output a fused feature vector. ; Classification network pairs Process the data and output the class probability distribution. ,in This represents the real-time probability that the current network interface card (NIC) status belongs to the j-th category. Step 44: Select the category probability distribution The category corresponding to the highest probability value is taken as the detection result, i.e.: result = argmax( ), where result is the final output state judgment; Step 45: Feed the detection results back to the Spine-Leaf network operation and maintenance system in real time. If the system is determined to be in a fault state, trigger the corresponding alarm or fault handling process simultaneously. At the same time, continue to collect the RDMA network card status data for the next time period and repeat steps 41-44 until the monitoring task is terminated.

Images