High-speed rail traction system fault and working condition classification method and device and storage medium

Abstract

The invention discloses a high-speed rail traction system fault and working condition classification method and device and a storage medium. The method comprises the steps that a sensor is used for collecting and processing fault signals in a high-speed rail traction system; the construction of the model comprises construction of a task sharing network and construction of a set task network; dividing an input fault sample into a training set and a test set; selecting a specified subset from the training set for model training, and updating model parameters through back propagation; iteratively calculating a total loss function of the fault classification task and the working condition classification task, and synchronously updating corresponding model parameters until the model realizes convergence in the two tasks; respectively using a Softmax cross entropy function to calculate probability distribution of the two tasks; and carrying out accurate classification by adopting the trained model. According to the method, classification tasks of fault types and working conditions can be completed in one model at the same time, the comprehensiveness and efficiency of diagnosis are improved, multi-task classification under a single network framework is achieved, and the system complexity is reduced.

Description

Technical Field

[0001] The present invention relates to the field of high-speed rail traction technology, and in particular to a method, device and storage medium for classifying faults and working conditions of a high-speed rail traction system. Background Art

[0002] High-speed rail is becoming an increasingly popular mode of transportation around the world, favored for its safety, punctuality, comfort and efficiency. The traction asynchronous motor of a high-speed rail drives the wheels through the power transmission system, directly affecting key performance indicators such as train speed, acceleration and traction. Since high-speed rail needs to operate at high speed for a long time in harsh environments, its traction system is prone to failure, which in turn leads to high-speed rail delays and a series of economic losses. Therefore, as a key component of the propulsion system, fault monitoring and diagnosis of traction asynchronous motors are crucial to maintaining the overall safe operation of high-speed trains.

[0003] Although some researchers are currently using deep learning technology to learn the operating data of high-speed rail traction systems and classify fault types based on deep learning models. However, conventional deep learning-based methods are usually limited to classifying the fault types of traction systems, and it is difficult to consider the working conditions of the equipment at the same time. If the sensors used to monitor the working conditions in high-speed rail equipment are not installed or damaged, operators will have difficulty accessing key information about the working status of the system. This lack of information may lead to incorrect decisions when a fault occurs, which may cause unnecessary losses. Therefore, there is a need for a method that can simultaneously solve fault classification and working condition classification to effectively manage potential fault scenarios in high-speed rail traction systems, which is an urgent problem that needs to be solved in this field. Summary of the invention

[0004] The present invention proposes a method, device and storage medium for classifying faults and working conditions of a high-speed railway traction system, which can solve at least one of the technical problems in the background technology.

[0005] To achieve the above object, the present invention adopts the following technical solutions:

[0006] A method for classifying faults and working conditions of a high-speed railway traction system comprises the following steps:

[0007] Use sensors to collect fault signals in the high-speed rail traction system, normalize the collected signals, and divide them into sample segments of set lengths;

[0008] Constructing the model includes constructing a task sharing network and constructing a setting task network. Before training the model, initial values ​​are given to the weights and biases in the model.

[0009] The input fault samples are randomly shuffled and divided into training set and test set. During the iterative training process, a specified subset is selected from the training set for model training, and the model parameters are updated through back propagation.

[0010] Iteratively calculate the total loss function of the fault classification task and the working condition classification task, and synchronously update the corresponding model parameters until the model converges in both tasks;

[0011] For the test samples of the fault classification task and the working condition classification task, the Softmax cross entropy function is used to calculate the probability distribution of the two tasks respectively. The category with the highest probability in each output is the prediction result of the task;

[0012] The trained model is used to integrate fault data of related tasks and accurately classify different but related tasks at the same time.

[0013] Furthermore, constructing a task sharing network includes:

[0014] A general feature extraction network is built under the deep learning framework to uniformly extract features from data from different sensors and different faults and working conditions, providing common features for downstream classification;

[0015] By adopting a multi-scale convolutional network, parallel convolutional layers and convolutional kernels of different scales are deployed to extract multi-level and multi-angle features;

[0016] For the left network branch in the task sharing network, a convolutional layer with a large-scale convolutional kernel is used to extract global fault features, while for the right network branch, a convolutional layer with a small-scale convolutional kernel is used to extract local fault features;

[0017] After each convolutional layer, batch normalization and ReLU activation functions are set to maintain the stability of the model gradient and activate features; then, the global and local fault features extracted by the two network branches are summed to integrate multi-scale fault features and used to input into the set task network for the next step of processing.

[0018] Furthermore, the task network construction part is configured to further extract refined task features based on the multi-scale fault features output by the shared network, and is used for exclusive classification of different fault types and operating conditions;

[0019] In this part, the joint attention module is set up, which uses the weight evaluation coefficient to determine the necessity of activating the attention mechanism;

[0020] Multiple joint attention modules are stacked in the task network, allowing the model to automatically decide which attention modules to activate or inhibit, thereby preventing feature loss due to incorrect attention.

[0021] Furthermore, the process of the joint attention module is divided into five stages:

[0022] Stage 1: Calculate the attention coefficient

[0023] Assume that the input feature vector of the joint attention module is represented as X = [x1, x2, ..., x n ], it is first input into a 1×1 convolution for preliminary feature extraction, and then transmitted to the global average pooling layer, i.e., the GAP layer, to average the input fault feature vector;

[0024] The GAP layer compresses a one-dimensional feature vector into a single scalar value, so the multiple input vectors are reduced to a single vector Y; then, vector Y is input into a one-dimensional convolution and a 1×1 convolution for feature extraction and channel compression; finally, the Sigmoid function is used to normalize the value of each element in the output vector of the 1×1 convolution to the range of 0 to 1, and then the attention coefficient S is obtained, and the value of each element in S can represent the importance of the corresponding feature vector;

[0025] The calculation process of stage 1 is expressed as follows:

[0026] S=σ(F3(F2(GAP(F1(X)))))

[0027] Among them, F1 and F3 represent 1×1 convolutional layers, F2 represents a one-dimensional convolutional layer, σ represents the Sigmoid function, and S represents the attention coefficient;

[0028] Stage 2: Sensitive feature weighting

[0029] The obtained attention coefficient S is used to weight the sensitive feature vectors, thereby increasing the weight of important features and reducing the influence of irrelevant features on model parameters; the input X of the joint attention module is convolved by a 1×1 convolution layer and then a one-dimensional convolution to extract deep features; then, the extracted deep features are weighted using the attention coefficient S to enhance sensitive features and suppress the influence of irrelevant features; finally, a residual structure is added to retain shallow fault features and prevent potential feature loss; the above process is expressed as follows:

[0030]

[0031] Where F4 represents a one-dimensional convolutional layer, and ⊙ represents element-wise multiplication;

[0032] Stage 3, non-attention feature extraction

[0033] In the joint attention module, an attention-free network stream is introduced into the module to extract deep fault features. The network stream consists of a one-dimensional convolution layer and a 1×1 convolution layer. The extracted attention-free fault features are used to concatenate with the attention-sensitive fault features to temporarily save two sets of fault features. The above process is expressed as follows:

[0034]

[0035] Among them, F5 and F6 represent one-dimensional convolutional layers, F7 represents a 1×1 convolutional layer, and Concat represents a feature concatenation operation;

[0036] Stage 4: Calculate evaluation weights

[0037] First, the fault feature X is transmitted to the GAP layer to increase the receptive field and extract the global information of the feature vector, and then it undergoes two layers of 1×1 convolutional layers to introduce nonlinear transformation; finally, the evaluation weight is obtained through the fully connected layer and the SoftMax function. The weight is calculated by the model based on the input X, rather than a fixed value set manually; once the input X changes, the evaluation weight will also change accordingly; in addition, the SoftMax function constrains the sum of the evaluation weight values ​​to 1, for the splicing feature Generate normalized evaluation weights; the calculation process of evaluation weights is as follows:

[0038] Z=δ(FC(F9(F8(GAP(X)))))

[0039] Among them, F8 and F9 represent 1×1 convolutional layers, FC represents a fully connected layer, and δ represents a SoftMax function;

[0040] Stage 5, attention evaluation and module output

[0041] At this stage, the obtained attention evaluation weight Z will be used to calculate the weights of the attention network flow and the non-attention network flow, thereby promoting active and suppressing redundant attention mechanisms; the evaluation weight Z is multiplied by the concatenated feature Combined to determine the weighted contribution of attention and non-attention feature vectors, as follows:

[0042]

[0043] After determining the proportion of attention and non-attention features, the obtained features It is input into a one-dimensional convolutional layer to further extract deep fault features; then, the extracted features are combined with the input X of the joint attention module to retain the original features and avoid potential feature loss; finally, the output of the joint attention module is obtained as follows:

[0044]

[0045] After feature extraction by the joint attention module in the set task network, the SoftMax cross entropy function is used to calculate the classification results of the two set task network flows respectively, that is, to obtain the categories of faults and working conditions.

[0046] On the other hand, the present invention further discloses a computer-readable storage medium storing a computer program, wherein when the computer program is executed by a processor, the processor executes the steps of the above method.

[0047] On the other hand, the present invention further discloses a computer device, including a memory and a processor, wherein the memory stores a computer program, and when the computer program is executed by the processor, the processor executes the steps of the above method.

[0048] It can be seen from the above technical solution that the classification method of high-speed railway traction system faults and working conditions of the present invention has the following beneficial effects:

[0049] 1) The present invention can simultaneously complete the classification tasks of fault types and working conditions in one model, thereby improving the comprehensiveness and efficiency of diagnosis. Compared with the traditional method that requires the construction of multiple models separately, the present invention realizes multi-task classification under a single network framework, reducing the complexity of the system.

[0050] 2) Under the multi-task learning framework proposed in this invention, different tasks (fault classification task and working condition classification task) can partially share underlying features through the task sharing network, effectively capture features related to different tasks, and improve feature representation capabilities. At the same time, this sharing mechanism reduces the number of model parameters and helps alleviate the overfitting problem.

[0051] 3) The shared model structure developed by the present invention based on multi-task learning realizes efficient information exchange between tasks, reduces model redundant parameters, and reduces computing resource requirements. This is very beneficial for the deployment of embedded or edge devices in high-speed rail real-time monitoring systems. BRIEF DESCRIPTION OF THE DRAWINGS

[0052] Figure 1 is a flowchart of an embodiment of the present invention;

[0053] Figure 2 Schematic diagram of the joint attention module framework of an embodiment of the present invention;

[0054] Figure 3 A schematic diagram of a simulation platform according to an embodiment of the present invention;

[0055] Figure 4 A visualization view corresponding to each operation signal of an embodiment of the present invention;

[0056] Figure 5 is a confusion matrix of the classification results of ten fault states according to an embodiment of the present invention;

[0057] Figure 6 This is a confusion matrix of the classification results of three operating conditions according to an embodiment of the present invention. DETAILED DESCRIPTION

[0058] In order to make the purpose, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments.

[0059] The embodiment of the present invention provides an intelligent classification method specifically for high-speed rail traction systems, such as Figure 1 The method includes the following processes: operating signal acquisition, task sharing network construction, setting task network construction and fault and operating condition classification, so as to efficiently and accurately identify the fault type and operating condition in the traction system.

[0060] The operation signal acquisition part is mainly used for real-time acquisition of various operation signal data of the high-speed rail traction system, covering various electrical, mechanical and operating condition indicators, including but not limited to voltage, current, speed, temperature, etc. First, high-precision sensors are arranged at key parts of the high-speed rail traction system to monitor the operating status of various parts of the traction system in multiple dimensions. The acquisition module acquires signals in real time at a high rate (such as 2.5kHz) and pre-processes the collected data, such as filtering, denoising, normalization and segmentation, to ensure the signal quality and robustness of the classification model. The data is transmitted to the central processing system through a high-speed data link, supporting a distributed architecture to facilitate large-scale deployment and multi-point real-time monitoring.

[0061] The task sharing network construction part builds a general feature extraction network under the deep learning framework to uniformly extract features from data from different sensors and different faults and working conditions, providing common features for downstream classification. By adopting a multi-scale convolutional network, parallel convolutional layers and convolutional kernels of different scales are deployed to extract multi-level and multi-angle features. The main purpose of this module design is to mine multi-scale features in fault signals, which helps to capture subtle differences in different fault types and working conditions and improve the generalization of shared features.

[0062] like Figure 1 As shown, for the network branch on the left side of the task sharing network, the present invention uses a convolution layer with a large-scale convolution kernel to extract global fault features, while for the network branch on the right side, the present invention uses a convolution layer with a small-scale convolution kernel to extract local fault features. After each convolution layer, batch normalization (BN) and ReLU activation functions are set to maintain the stability of the model gradient and activate features. Subsequently, the global and local fault features extracted by the two network branches are summed to integrate multi-scale fault features and used to input into the set task network for the next step of processing.

[0063] The set task network construction part is mainly aimed at the multi-scale fault features based on the shared network output. The set task network module further extracts refined task features for exclusive classification of different fault types and operating conditions. In this part, the present invention designs a joint attention module, which uses weight evaluation coefficients to determine the necessity of activating the attention mechanism. If these coefficients indicate potential negative effects, the attention channel will be blocked and restored to a regular convolution module. Multiple joint attention modules are stacked in the set task network, so that the model can automatically decide which attention modules to activate or suppress, thereby preventing feature loss due to incorrect attention. In general, the process of the joint attention module can be divided into five stages. The framework of the joint attention module is as follows: Figure 2 shown.

[0064] Stage 1: Calculate the attention coefficient

[0065] Assume that the input feature vector of the joint attention module is represented as X = [x1, x2, ..., x n ], it is first input into a 1×1 convolution for preliminary feature extraction, and then transmitted to the global average pooling (GAP) layer to average the input fault feature vector. The GAP layer can compress a one-dimensional feature vector into a single scalar value, so the multiple input vectors are reduced to a single vector Y. Subsequently, Y is input into a one-dimensional convolution and a 1×1 convolution for feature extraction and channel compression. Finally, the Sigmoid function is used to normalize the value of each element in the output vector of the 1×1 convolution to the range of 0 to 1, and then obtain the attention coefficient S, in which the value of each element can represent the importance of the corresponding feature vector. In general, the calculation process of stage 1 can be expressed as follows:

[0066] S=σ(F3(F2(GAP(F1(X)))))

[0067] Among them, F1 and F3 represent 1×1 convolutional layers, F2 represents a one-dimensional convolutional layer, σ represents the Sigmoid function, and S represents the attention coefficient.

[0068] Stage 2: Sensitive feature weighting

[0069] The obtained attention coefficient S can be used to weight the sensitive feature vectors, thereby increasing the weights of important features and reducing the impact of irrelevant features on model parameters. Specifically, the input X of the joint attention module is convolved by a 1×1 convolution layer and then a one-dimensional convolution to extract deep features. Then, the extracted deep features are weighted using the attention coefficient S to enhance sensitive features and suppress the influence of irrelevant features. Finally, a residual structure is added to retain shallow fault features and prevent potential feature loss. The above process can be expressed as follows:

[0070]

[0071] Where F4 represents a one-dimensional convolutional layer and ⊙ represents element-wise multiplication.

[0072] Stage 3, non-attention feature extraction

[0073] Generally speaking, the attention mechanism is not always effective. Therefore, in the joint attention module, an attention-free network stream is introduced into the module to extract deep fault features. The network stream consists of a one-dimensional convolution layer and a 1×1 convolution layer. The extracted attention-free fault features are used to concatenate with the attention-sensitive fault features to temporarily save two sets of fault features. The above process can be expressed as follows:

[0074]

[0075] Among them, F5 and F6 represent one-dimensional convolutional layers, F7 represents a 1×1 convolutional layer, and Concat represents a feature concatenation operation.

[0076] Stage 4: Calculate evaluation weights

[0077] In order to evaluate the necessity of the attention mechanism in the joint attention module, the present invention designs attention evaluation weights to determine whether the current module needs an attention mechanism, as well as the proportion of attention network flows and non-attention network flows. First, the fault feature X is transmitted to the GAP layer to increase the receptive field and extract the global information of the feature vector, and then undergoes two layers of 1×1 convolutional layers to introduce nonlinear transformations. Finally, the evaluation weight is obtained through the fully connected layer and the SoftMax function. The weight is calculated by the model based on the input X, rather than a fixed value set artificially. Once the input X changes, the evaluation weight will also change accordingly. In addition, the SoftMax function can constrain the sum of the values ​​of the evaluation weights to 1, so it can be used for splicing features. Generate normalized evaluation weights. The calculation process of evaluation weights is as follows:

[0078] Z=δ(FC(F9(F8(GAP(X)))))

[0079] Among them, F8 and F9 represent 1×1 convolutional layers, FC represents the fully connected layer, and δ represents the SoftMax function.

[0080] Stage 5, attention evaluation and module output

[0081] At this stage, the obtained attention evaluation weight Z will be used to calculate the weights of the attention network flow and the non-attention network flow, thereby promoting active and suppressing redundant attention mechanisms. Therefore, the present invention multiplies the evaluation weight Z with the concatenated feature by element multiplication. Combined to determine the weighted contribution of attention and non-attention feature vectors, as follows:

[0082]

[0083] After determining the proportion of attention and non-attention features, the obtained features It is fed into a one-dimensional convolutional layer to further extract deep fault features. Subsequently, the extracted features are combined with the input X of the joint attention module to preserve the original features and avoid potential feature loss. Finally, the output of the joint attention module can be obtained as follows:

[0084]

[0085] After feature extraction by the joint attention module in the set task network, the SoftMax cross entropy function is used to calculate the classification results of the two set task network flows respectively, that is, to obtain the categories of faults and working conditions.

[0086] In general, the method proposed in the present invention is applied to high-speed rail fault diagnosis and is mainly divided into six steps.

[0087] Step 1. Data collection and preprocessing: Use sensors to collect fault signals in the high-speed rail traction system, such as vibration, voltage, current signals, etc. The collected signals are normalized and cut into sample segments of a specific length.

[0088] Step 2. Model initialization: Before training the model, give small initial values ​​to the weights and biases in the model.

[0089] Step 3. Model training: Randomly shuffle the input fault samples and divide them into training set and test set. In the iterative training process, select a specified subset from the training set for model training, and update the model parameters through back propagation.

[0090] Step 4. Model iterative optimization: Iteratively calculate the total loss function of the two tasks and synchronously update the corresponding model parameters until the model converges in both tasks.

[0091] Step 5. Model testing: For the test samples of the fault classification task and the working condition classification task, the Softmax cross entropy function is used to calculate the probability distribution of the two tasks. The category with the highest probability in each output is the prediction result of the task.

[0092] Step 6. Model application: The trained model can effectively integrate the fault data of related tasks and accurately classify different but related tasks (fault classification task and working condition classification task).

[0093] The embodiment of the present invention uses a high-speed train traction control system hardware-in-the-loop simulation platform jointly established by Central South University and Zhuzhou Electric Locomotive Research Institute to verify the proposed method. Figure 3 As shown. The simulation platform mainly consists of five parts: dSPACE real-time simulator, power supply, tracking control unit, personal computer and signal conditioner. The collected data includes three predefined fault types: broken rotor bars, inter-turn short circuit and air gap eccentricity, each with three severity levels: mild, moderate and severe. These fault signals are recorded by sensors that monitor the DC side voltage at a sampling frequency of 2.5kHz. In addition, the dataset covers three different operating conditions of high-speed trains: 20 km / h, 160 km / h and 280 km / h. For each operating condition, there are ten operating states, including nine fault states and one normal state. The detailed information of the HIL high-speed train traction control system simulation platform dataset is shown in Table 1. In addition, the visualization diagram corresponding to each operating signal is shown in Figure 4 shown.

[0094] Table 1

[0095]

[0096]

[0097] That is to say, in the verification stage of the hardware-in-the-loop simulation platform of the high-speed train traction control system, the present invention can classify ten fault states and three operating conditions at the same time. The experimental results obtained are as follows Figure 5 and Figure 6 shown. Figure 5 Represents the confusion matrix of the classification results for ten fault states, Figure 6 Represents the confusion matrix of the classification results for the three operating conditions.

[0098] On the other hand, the present invention further discloses a computer-readable storage medium storing a computer program, wherein when the computer program is executed by a processor, the processor executes the steps of the above method.

[0099] On the other hand, the present invention further discloses a computer device, including a memory and a processor, wherein the memory stores a computer program, and when the computer program is executed by the processor, the processor executes the steps of the above method.

[0100] In another embodiment provided in the present application, a computer program product comprising instructions is also provided, which, when executed on a computer, enables the computer to execute any of the methods for classifying high-speed railway traction system faults and operating conditions in the above-mentioned embodiments.

[0101] It is understandable that the system, device and storage medium provided in the embodiments of the present invention correspond to the method provided in the embodiments of the present invention, and the explanation, examples and beneficial effects of the relevant contents can refer to the corresponding parts in the above methods.

[0102] In the above embodiments, it can be implemented in whole or in part by software, hardware, firmware or any combination thereof. When implemented using software, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the process or function described in the embodiment of the present application is generated in whole or in part. The computer may be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions may be stored in a computer-readable storage medium, or transmitted from one computer-readable storage medium to another computer-readable storage medium, for example, the computer instructions may be transmitted from a website site, computer, server or data center by wired (e.g., coaxial cable, optical fiber, digital subscriber line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.) mode to another website site, computer, server or data center. The computer-readable storage medium may be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more available media integrated. The available medium may be a magnetic medium, (e.g., a floppy disk, a hard disk, a tape), an optical medium (e.g., a DVD), or a semiconductor medium (e.g., a solid-state drive Solid State Disk (SSD)), etc.

[0103] It should be noted that, in this article, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device. In the absence of further restrictions, the elements defined by the sentence "comprise a ..." do not exclude the existence of other identical elements in the process, method, article or device including the elements.

[0104] Each embodiment in this specification is described in a related manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiment.

[0105] The above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that the technical solutions described in the aforementioned embodiments may still be modified, or some of the technical features may be replaced by equivalents. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for classifying faults and working conditions of a high-speed railway traction system, characterized in that: The following steps are included: Use sensors to collect fault signals in the high-speed rail traction system, normalize the collected signals, and divide them into sample segments of set lengths; Constructing the model includes constructing a task sharing network and constructing a setting task network. Before training the model, initial values ​​are given to the weights and biases in the model. The input fault samples are randomly shuffled and divided into training set and test set; During the iterative training process, a specified subset is selected from the training set for model training, and the model parameters are updated through back propagation; Iteratively calculate the total loss function of the fault classification task and the working condition classification task, and synchronously update the corresponding model parameters until the model converges in both tasks; For the test samples of the fault classification task and the working condition classification task, the Softmax cross entropy function is used to calculate the probability distribution of the two tasks respectively. The category with the highest probability in each output is the prediction result of the task; The trained model is used to integrate fault data of related tasks and accurately classify different but related tasks at the same time.

2. The method for classifying high-speed railway traction system faults and working conditions according to claim 1, characterized in that: Constructing a task sharing network includes: A general feature extraction network is built under the deep learning framework to uniformly extract features from data from different sensors and different faults and working conditions, providing common features for downstream classification; By adopting a multi-scale convolutional network, parallel convolutional layers and convolutional kernels of different scales are deployed to extract multi-level and multi-angle features; For the left network branch in the task sharing network, a convolutional layer with a large-scale convolutional kernel is used to extract global fault features, while for the right network branch, a convolutional layer with a small-scale convolutional kernel is used to extract local fault features; After each convolutional layer, batch normalization and ReLU activation functions are set to maintain model gradient stability and activate features; Subsequently, the global and local fault features extracted by the two network branches are summed to integrate the multi-scale fault features and used as input into the set task network for the next step of processing.

3. The method for classifying high-speed railway traction system faults and operating conditions according to claim 1, characterized in that: The task network construction part is configured to further extract detailed task features based on the multi-scale fault features output by the shared network, and is used for exclusive classification of different fault types and operating conditions; In this part, the joint attention module is set up, which uses the weight evaluation coefficient to determine the necessity of activating the attention mechanism; Multiple joint attention modules are stacked in the task network, allowing the model to automatically decide which attention modules to activate or inhibit, thereby preventing feature loss due to incorrect attention.

4. The method for classifying high-speed railway traction system faults and working conditions according to claim 3 is characterized in that: The process of the joint attention module is divided into five stages: Stage 1: Calculate the attention coefficient Assume that the input feature vector of the joint attention module is represented as X = [x1, x2, ..., x n ], it is first input into a 1×1 convolution for preliminary feature extraction, and then transmitted to the global average pooling layer, i.e., the GAP layer, to average the input fault feature vector; The GAP layer compresses a one-dimensional feature vector into a single scalar value, so the multiple input vectors are reduced to a single vector Y; Subsequently, the vector Y is input into a one-dimensional convolution and a 1×1 convolution for feature extraction and channel compression; finally, the Sigmoid function is used to normalize the value of each element in the output vector of the 1×1 convolution to the range of 0 to 1, thereby obtaining the attention coefficient S, in which the value of each element can represent the importance of the corresponding feature vector; The calculation process of stage 1 is expressed as follows: S=σ(F3(F2(GAP(F1(X))))) Among them, F1 and F3 represent 1×1 convolutional layers, F2 represents a one-dimensional convolutional layer, σ represents the Sigmoid function, and S represents the attention coefficient; Stage 2: Sensitive feature weighting The obtained attention coefficient S is used to weight the sensitive feature vectors, thereby increasing the weight of important features and reducing the impact of irrelevant features on model parameters; the input X of the joint attention module is convolved by a 1×1 convolution layer and then a one-dimensional convolution to extract deep features; Then, the extracted deep features are weighted using the attention coefficient S to enhance sensitive features and suppress the influence of irrelevant features; finally, the residual structure is added to retain shallow fault features and prevent potential feature loss; the above process is expressed as follows: Where F4 represents a one-dimensional convolutional layer, and ⊙ represents element-wise multiplication; Stage 3, non-attention feature extraction In the joint attention module, an attention-free network stream is introduced into the module to extract deep fault features. The network stream consists of a one-dimensional convolution layer and a 1×1 convolution layer. The extracted attention-free fault features are used to concatenate with the attention-sensitive fault features to temporarily save two sets of fault features. The above process is expressed as follows: Among them, F5 and F6 represent one-dimensional convolutional layers, F7 represents a 1×1 convolutional layer, and Cocat represents a feature concatenation operation; Stage 4: Calculate evaluation weights First, the fault feature X is transmitted to the GAP layer to increase the receptive field and extract the global information of the feature vector, and then it undergoes two layers of 1×1 convolutional layers to introduce nonlinear transformation; finally, the evaluation weight is obtained through the fully connected layer and the SoftMax function. The weight is calculated by the model based on the input X, rather than a fixed value set manually; once the input X changes, the evaluation weight will also change accordingly; in addition, the SoftMax function constrains the sum of the evaluation weight values ​​to 1, for the splicing feature Generate normalized evaluation weights; the calculation process of evaluation weights is as follows: Z=δ(FC(F9(F8(GAP(X))))) Among them, F8 and F9 represent 1×1 convolutional layers, FC represents a fully connected layer, and δ represents a SoftMax function; Stage 5, attention evaluation and module output At this stage, the obtained attention evaluation weight Z will be used to calculate the weights of the attention network flow and the non-attention network flow, thereby promoting active and suppressing redundant attention mechanisms; the evaluation weight Z is multiplied by the concatenated feature Combined to determine the weighted contribution of attention and non-attention feature vectors, as follows: After determining the proportion of attention and non-attention features, the obtained features It will be input into a one-dimensional convolutional layer to further extract deep fault features; Subsequently, the extracted features are combined with the input X of the joint attention module to preserve the original features and avoid potential feature loss; finally, the output of the joint attention module is obtained as follows: After feature extraction by the joint attention module in the set task network, the SoftMax cross entropy function is used to calculate the classification results of the two set task network flows respectively, that is, to obtain the categories of faults and working conditions.

5. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the processor is caused to perform the steps of the method according to any one of claims 1 to 4.

6. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: When the computer program is executed by the processor, the processor is caused to perform the steps of the method according to any one of claims 1 to 4.

Images