Fault detection method and system for gearbox of wind driven generator

Abstract

The invention discloses a wind driven generator gearbox fault detection method and system, and the method comprises the steps: obtaining a gearbox vibration signal, carrying out the preprocessing of a gearbox vibration signal sequence, and obtaining at least one gearbox vibration sub-signal, and a gearbox state corresponding to the at least one gearbox vibration sub-signal; inputting the at least one gear box vibration sub-signal sequence and the corresponding gear box state into a preset GearFaultNet network, and performing iterative training on the GearFaultNet network to obtain a gear box fault detection model; and inputting the obtained real-time gearbox vibration signal into the gearbox fault detection model, and outputting to obtain a gearbox fault state corresponding to the real-time gearbox vibration signal. Multiple limitations of a traditional convolutional network are overcome, and the accuracy and generalization ability of mechanical fault diagnosis are remarkably improved.

Description

TECHNICAL FIELD

[0001] The present application belongs to the technical field of gear box fault detection, and particularly relates to a wind turbine gear box fault detection method and system. BACKGROUND

[0002] With the continuous development of intelligentization and automation technology, fault diagnosis has become a crucial link in the fields of industrial production, transportation, equipment management, etc. In particular, in the operation process of key systems such as wind turbines, mechanical equipment, and automobile engines, timely and accurate discovery and solution of equipment faults can not only avoid production downtime and reduce maintenance costs, but also improve the operation efficiency of equipment and prolong its service life. Therefore, how to accurately predict and identify equipment faults using sensor data or vibration signals has become a core technical requirement for equipment maintenance and protection. SUMMARY

[0003] The present application provides a wind turbine gear box fault detection method and system, which solves the technical problem of low accuracy of existing wind turbine gear box fault detection.

[0004] In a first aspect, the present application provides a wind turbine gear box fault detection method, comprising:

[0005] Obtaining a gear box vibration signal and preprocessing the gear box vibration signal sequence to obtain at least one gear box vibration sub-signal and a gear box state corresponding to the at least one gear box vibration sub-signal;

[0006] Inputting the at least one gear box vibration sub-signal sequence and the corresponding gear box state into a pre-set GearFaultNet network and iteratively training the GearFaultNet network to obtain a gear box fault detection model;

[0007] Inputting the obtained real-time gear box vibration signal into the gear box fault detection model, and the gear box fault detection model outputs a gear box fault state corresponding to the real-time gear box vibration signal.

[0008] In a second aspect, the present application provides a wind turbine gear box fault detection system, comprising:

[0009] The obtaining module is configured to obtain a gear box vibration signal and preprocess the gear box vibration signal sequence to obtain at least one gear box vibration sub-signal and a gear box state corresponding to the at least one gear box vibration sub-signal;

[0010] The training module is configured to input the at least one gearbox vibrating sub-signal sequence and the corresponding gearbox state into a preset GearFaultNet network, and to iteratively train the GearFaultNet network to obtain a gearbox fault detection model.

[0011] The output module is configured to input the acquired real-time gearbox vibration signal into the gearbox fault detection model, and the gearbox fault detection model outputs the gearbox fault state corresponding to the real-time gearbox vibration signal.

[0012] Thirdly, an electronic device is provided, comprising: at least one processor, and a memory communicatively connected to the at least one processor, wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the steps of the wind turbine gearbox fault detection method according to any embodiment of the present invention.

[0013] Fourthly, the present invention also provides a computer-readable storage medium having a computer program stored thereon, wherein when the program instructions are executed by a processor, the processor performs the steps of the wind turbine gearbox fault detection method according to any embodiment of the present invention.

[0014] This application presents a wind turbine gearbox fault detection method and system, proposing an innovative multidimensional adaptive convolutional neural network model that integrates multi-size adaptive convolutional kernels, a neurobiologically inspired channel selection mechanism, joint learning of local and global convolutions, and a dynamic pooling module. The employed multidimensional adaptive convolutional kernels can adaptively adjust their size according to the time-frequency characteristics of the input signal, achieving efficient capture of multi-scale features. The neurobiologically inspired channel selection mechanism simulates selective activation of neurons, dynamically filtering key feature channels and improving computational efficiency. The joint learning module of local and global convolutions collaboratively extracts dependencies at different scales, enhancing the model's global and local understanding of the signal. The dynamic pooling module flexibly adjusts the pooling window size according to input characteristics, ensuring effective feature extraction and information integrity. This design not only overcomes several limitations of traditional convolutional networks but also significantly improves the accuracy and generalization ability of mechanical fault diagnosis. Attached Figure Description

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

[0016] Figure 1A flowchart of a wind turbine gearbox fault detection method provided in an embodiment of the present invention;

[0017] Figure 2 A flowchart of the GearFaultNet backbone network is provided for a specific embodiment of the present invention;

[0018] Figure 3 A flowchart of a multidimensional adaptive convolution module is provided for a specific embodiment of the present invention;

[0019] Figure 4 A flowchart illustrating a self-attention mechanism module of a specific embodiment of the present invention is provided;

[0020] Figure 5 A flowchart illustrating a local and global convolutional joint learning module is provided for one embodiment of the present invention.

[0021] Figure 6 A flowchart of a dynamic pooling module is provided for a specific embodiment of the present invention;

[0022] Figure 7 This is a structural block diagram of a wind turbine gearbox fault detection system provided in an embodiment of the present invention;

[0023] Figure 8 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention. Detailed Implementation

[0024] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, 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, 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.

[0025] Please see Figure 1 The diagram shows a flowchart of a wind turbine gearbox fault detection method according to this application.

[0026] like Figure 1 As shown, the method for detecting faults in wind turbine gearboxes specifically includes the following steps:

[0027] Step S101: Obtain the gearbox vibration signal and preprocess the gearbox vibration signal sequence to obtain at least one gearbox vibration sub-signal and the gearbox state corresponding to the at least one gearbox vibration sub-signal.

[0028] In this step, the gearbox vibration signal is segmented to obtain multiple gearbox vibration sub-signals of fixed length, expressed as follows:

[0029] x i =[x[i·S],x[i·S+1],...,x[i·S+L-1]],

[0030] In the formula, x i This is the signal of the i-th gearbox resonator.

[0031] Each gearbox vibrating sub-signal is assigned a corresponding label based on the actual gearbox state, thus obtaining the gearbox state corresponding to the at least one gearbox vibrating sub-signal sequence. The expression for assigning the corresponding label is as follows:

[0032]

[0033] In the formula, y i This is the label corresponding to the i-th gearbox resonator signal.

[0034] Step S102: Input the at least one gearbox vibrating sub-signal sequence and the corresponding gearbox state into the preset GearFaultNet network, and perform iterative training on the GearFaultNet network to obtain the gearbox fault detection model.

[0035] In this step, the gearbox vibrating sub-signal is processed by a multidimensional adaptive convolution module, which uses multiple convolution kernel sizes to extract features at different scales to obtain the first output feature. The first output feature is then subjected to nonlinear transformation and feature compression by the ReLU activation function and MaxPool1d pooling layer to obtain the second output feature.

[0036] The second output feature is extracted through a multidimensional adaptive convolutional layer to obtain a third output feature, and the third output feature is input into a self-attention mechanism module, which outputs a fourth output feature.

[0037] The fourth output feature is sequentially input into the local convolution module and the global convolution module, and local features and global features are output respectively. The local features and global features are then fused through the local and global convolution joint learning module to obtain the fifth output feature.

[0038] The fifth output feature is pooled by the dynamic pooling module to obtain the sixth output feature, and the final detection result is output by the classifier. The loss is calculated by the adaptive weighted cross-entropy loss function, and the model is trained by backpropagation to obtain the gearbox fault detection model.

[0039] It should be noted that the expression for the adaptive weighted cross-entropy loss function is:

[0040]

[0041] In the formula, The adaptive weighted cross-entropy loss function is... This represents the averaging operation, which calculates the average across all samples in the batch, ensuring that the loss is independent of the sample size. B represents the number of samples processed in the next forward propagation. This means summing the losses for each sample b in the batch, calculating the loss for each sample, and then averaging the sums to obtain the loss for the entire batch. This represents summing over all classes j to calculate the loss for each sample across all classes, N. cls w represents the number of possible classes in the model's classification task. j y represents the weight of class j. b，j Let b be the true label of the b-th sample in class j, log(P) b，j To perform a logarithmic transformation on the predicted probability, P b，j Let be the predicted probability of the b-th sample in class j, freq(j) be the frequency of class j in the training set, ∈ be a minimal constant used to avoid division by zero error, and exp(Z) be the predicted probability of the b-th sample in class j. b，j To apply the exponential function to the predicted score of category j, Sum the index scores for all categories, then normalize them to ensure that the sum of the probabilities for all categories is 1.

[0042] Step S103: The acquired real-time gearbox vibration signal is input into the gearbox fault detection model, and the gearbox fault detection model outputs the gearbox fault state corresponding to the real-time gearbox vibration signal.

[0043] In summary, this application proposes an innovative multidimensional adaptive convolutional neural network model that integrates multi-size adaptive convolutional kernels, a neurobiologically inspired channel selection mechanism, joint learning of local and global convolutions, and a dynamic pooling module. The employed multidimensional adaptive convolutional kernels can adaptively adjust their size according to the time-frequency characteristics of the input signal, achieving efficient capture of multi-scale features. The neurobiologically inspired channel selection mechanism simulates selective activation of neurons, dynamically filtering key feature channels and improving computational efficiency. The joint learning module of local and global convolutions collaboratively extracts dependencies at different scales, enhancing the model's global and local understanding of the signal. The dynamic pooling module flexibly adjusts the pooling window size according to input characteristics, ensuring effective feature extraction and information integrity. This design not only overcomes several limitations of traditional convolutional networks but also significantly improves the accuracy and generalization ability of mechanical fault diagnosis.

[0044] In one specific embodiment, the wind turbine gearbox fault detection method includes the following steps:

[0045] Step 1: Preprocess the gearbox data of the wind turbine generator set collected by the sensor device.

[0046] Intelligent sensor devices are deployed inside the gearbox of a wind turbine generator to collect gearbox vibration signals. The intelligent platform then transmits the collected gearbox vibration signal data to a gearbox fault detection system in real time. This system can preprocess the gearbox vibration signals.

[0047] 1. Raw signal reading and representation

[0048] The gearbox vibration signal acquired by the sensor is a continuous time series:

[0049] x(t), t∈[0,T]

[0050] in:

[0051] x(t): The amplitude function of the vibration signal in the continuous time domain, where t is a continuous time variable;

[0052] t∈[0,T]: Time interval, from t=0 (sampling start) to t=T (sampling end);

[0053] T: Total duration of signal acquisition, in seconds (s);

[0054] The sampling frequency is f s Then the discrete signal can be expressed as:

[0055]

[0056] in:

[0057] f s Sampling frequency, measured in Hertz (Hz), represents the number of sampling points per second;

[0058] For a discrete sampled signal, the value of the nth sample point, where n is the sample point index, and the value ranges from 0 to N-1;

[0059] N = T × f s The total number of sampling points is equal to the sampling duration multiplied by the sampling frequency.

[0060] 2. Signal segmentation (window cutting)

[0061] To accommodate the input of a deep learning model, the long-time sequence needs to be divided into multiple fixed-length signal segments, each with L sampling points. The i-th signal segment is:

[0062] xi =[x[i·S],x[i·S+1],...,x[i·S+L-1]]

[0063] in:

[0064] x i The i-th segment signal represents a vector of length L extracted from the original signal;

[0065] L: The number of sampling points (window length) for each signal segment, a fixed length that determines the sequence length of the input model;

[0066] S: Window sliding step size, S≤L. If S<L, it means that the segments overlap, which can increase the data sample size.

[0067] x[i·S+1]: The value of the k-th sampling point in the segment, k=0,1,...,L-1.

[0068] i: Segment number, starting from 0.

[0069] 3. Tag assignment

[0070] Each signal segment is assigned a corresponding label based on the actual gearbox status:

[0071]

[0072] in:

[0073] y i The label corresponding to the i-th signal segment is used for classification training.

[0074] y i =0: The gearbox corresponding to the i-th signal segment is in a "normal" state;

[0075] y i =1: The gearbox corresponding to the i-th signal segment is in a "fault" state;

[0076] 4. Feature standardization

[0077] To eliminate the impact of signal amplitude differences on model training, each signal segment is standardized:

[0078]

[0079] in:

[0080] The standardized i-th segment of the signal has a mean of 0 and a standard deviation of 1.

[0081] μ i The mean (average value) of the i-th segment of the signal;

[0082] σi The standard deviation of the i-th segment of the signal reflects the degree of dispersion of the signal amplitude;

[0083] L: Window length, i.e., the number of sampling points contained in each signal segment;

[0084] The accumulation operation accumulates from the 0th sampling point to the (L-1)th sampling point;

[0085] x[i·S+k]: The amplitude of the k-th sampling point in the i-th signal segment;

[0086] i: Signal segment index, the number of the i-th signal segment;

[0087] S: Window sliding step size, which is the number of sampling points offset from the starting position of each signal segment relative to the previous segment;

[0088] The normalized amplitude (normalized result) of the k-th sampling point in the i-th signal segment;

[0089] x[i·S+k]: The original amplitude of the k-th sampling point in the i-th signal segment;

[0090] x[i·S+k]-μ i Centering the sampled data involves removing the mean to make the data mean zero.

[0091] 5. Dataset partitioning

[0092] All data The dataset is divided proportionally into: training set (for model training), validation set (for model parameter tuning and overfitting detection), and test set (for final model performance evaluation), as shown in the following expression:

[0093] p train +p val +p test =1

[0094] in:

[0095] p train The proportion of the training set;

[0096] p val The proportion of the validation set;

[0097] p test : The proportion of the test set.

[0098] 6. Data format storage

[0099] Save the partitioned data in a file format supported by the deep learning framework. This facilitates subsequent loading; for example, using the training set:

[0100]

[0101] in:

[0102] train.npz: Training set data file, containing the signal segments and labels used for training.

[0103] The standardized i-th segment of the signal has a mean of 0 and a standard deviation of 1.

[0104] y i The label corresponding to the i-th signal segment is used for classification training.

[0105] Step 2: Construct the GearFaultNet gear fault detection network model:

[0106] GearFaultNet is a wind turbine gear fault detection network model that combines multidimensional adaptive convolution, neurobiology-inspired channel selection mechanisms, and joint learning of local and global convolutions. Figure 2 As shown.

[0107] This model is an innovative 1D CNN network that combines multidimensional adaptive convolution, joint learning of local and global convolutions, self-attention mechanism, and dynamic pooling module. It aims to effectively extract and fuse different feature information for efficient classification tasks. First, the input signal passes through a multidimensional adaptive convolution module, which uses multiple convolution kernel sizes to extract features at different scales. Next, it undergoes non-linear transformation and feature compression using the ReLU activation function and MaxPool1d pooling layer. Then, the features enter multiple multidimensional adaptive convolution layers to progressively extract deeper features. Next, through the self-attention mechanism module, the model automatically adjusts the importance of different features based on the input features, enhancing its ability to perceive global information. Afterwards, through the joint learning module of local and global convolutions, the model combines features from both local and global convolutions, fully utilizing short-term and long-term dependencies. Following this, through the dynamic pooling module, the pooling window size is dynamically adjusted according to signal characteristics, improving the adaptability of feature extraction. Finally, the model's performance is evaluated using the CrossEntropyLoss loss function and accuracy, based on the classifier output. The overall model is highly efficient in feature extraction and fusion, which can significantly improve the performance and robustness of classification tasks.

[0108] GearFaultNet network structure:

[0109] 1. Input Layer: The model receives a one-dimensional signal (vibration data) as input. The input signal is first processed by a multi-dimensional adaptive convolution module (MultiDimensionalAdaptiveConv). This module uses multiple convolution kernels of different sizes (3, 5, 7) to extract multi-scale features from the one-dimensional signal. At the same time, it uses learnable weights to perform weighted summation on the convolution output. In this way, the model can better adapt to different signal features and extract feature information at different scales.

[0110] 2. Feature Extraction: After adaptive convolution processing, the signal features enter the ReLU activation function and the MaxPool1d pooling layer. Through these operations, the model compresses the high-frequency features of the signal and gradually reduces the feature dimension through pooling operations, thereby preserving key information and preparing for subsequent deep feature extraction.

[0111] 3. Self-Attention Mechanism: The signal features are further fed into the SelfAttention Module. This module uses query, key, and value to calculate attention weights. In this way, the model can adaptively adjust the weights of different features according to the characteristics of the signal, enhance the perception of key information, and reweight the input features globally.

[0112] 4. Local and Global Convolution Joint Learning: After the features are processed by self-attention, they are passed to the LocalGlobalConvolution joint module. This module processes the signal features in parallel through local convolution (using small convolution kernels) and global convolution (using large convolution kernels), thereby capturing both the short-term and long-term dependencies of the signal. Through the fusion of local and global features, the model can more comprehensively understand the different levels of information in the signal.

[0113] 5. Dynamic Pooling: Next, the signal features enter the Dynamic Pooling model. This module dynamically selects the size of the pooling window based on the characteristics of the signal. During the pooling process, the model can flexibly adjust the pooling strategy according to the changes in the input features, thereby effectively preserving important details and enhancing the adaptability of the model.

[0114] 6. Output Mapping: Finally, the pooled features are mapped through a classifier, which consists of fully connected layers and outputs the final classification result. The network output is the predicted class of the signal. The classifier uses CrossEntropyLoss to calculate the loss and is trained through backpropagation.

[0115] 7. Loss Function and Accuracy: The model uses CrossEntropyLoss as the standard for calculating loss during training. At the same time, torchmetrics is used to calculate the accuracy on the training and validation sets to evaluate the model's performance.

[0116] 8. Optimizer and Learning Rate Scheduling: The model uses the AdamW optimizer, combined with the ReduceLROnPlateau learning rate scheduler, which automatically adjusts the learning rate when the loss on the validation set stops decreasing, in order to achieve better convergence and improve training efficiency.

[0117] The network structure of GearFaultNet is explained below:

[0118] 1. Input layer

[0119] 1.1 Input Signal

[0120]

[0121] in:

[0122] X: The original input to the network, a three-dimensional tensor;

[0123] B: Batch size, the number of sequences processed in parallel at one time; 1: Number of input channels (single-channel vibration signal);

[0124] L: Length of each sequence (number of sampling points);

[0125] x b,1,n : The amplitude of the b-th signal at position n, B∈[1, B], n∈[0, L-1].

[0126] 1.2 Multi-scale convolution kernels

[0127] There are M=3 sets of convolution kernels, with lengths of k1=3, k2=5, and k3=7 respectively.

[0128]

[0129] in:

[0130] K m The m-th group can learn the convolutional kernel weights;

[0131] k m Rearranging the convolution kernel length determines the receptive field size;

[0132] C in : Input number of channels (=1);

[0133] C out Number of output channels (=32);

[0134] r: The index of the convolution kernel in the time dimension, r∈[0,k] m -1].

[0135] 1.3 Convolution Operation

[0136] F m =K m *X,m=1,2,3

[0137] in:

[0138] *: One-dimensional effective convolution, with a sliding inner product over the third dimension (time dimension);

[0139] The m-th group of convolution outputs features.

[0140] 1.4 Learnable Weight Normalization

[0141]

[0142] in:

[0143] w m Original learnable scalar weights (initialized to 1 / 3);

[0144] The normalized weights ensure that the sum of all weights is 1;

[0145] ∑: Summation symbol, summing the weights of all convolutional branches;

[0146] 1.5 Weighted Fusion Output

[0147]

[0148] in:

[0149] Weight the features of the m-th convolutional branch according to their importance;

[0150] The results from the three scale branches are summed channel by channel;

[0151] F: Output of MADConv-1, 32 channels, multi-scale fused features.

[0152] 1.6 Design of this step (Step 1)

[0153] Multi-scale receptive field: Short-term vibration peaks, medium-term harmonics and long-term trends are extracted in parallel using 3 / 5 / 7 length convolution kernels;

[0154] Adaptive weights During training, the network learns the most suitable combination of scales for different samples, thus achieving scale adaptation.

[0155] Maintaining length L: Same padding ensures subsequent timing alignment, making it convenient for residual or attention modules to directly reference it.

[0156] 2. Non-linear activation + MaxPool (32 channels → length L / 2)

[0157] 2.1 ReLU Activation

[0158] Feature tensor:

[0159]

[0160] Apply Rectified Linear Unit to it element by element

[0161] F' = σ(F), σ(z) = max(0,z)

[0162] in:

[0163] f b,c,n : The convolution value of the b-th sample, channel c, and position n;

[0164] σ(z): ReLU function, set to zero on the negative half-axis and equal on the positive half-axis;

[0165] z: Any input scalar when the activation function is applied, i.e., f in this context b,c,n ;

[0166] F': Features after activation, with dimensions remaining unchanged (B, 32, L);

[0167] 2.2 MaxPool(2) downsampling

[0168] Window length = step size = 2

[0169]

[0170] get:

[0171]

[0172] in:

[0173] h b,c,n After pooling, select the feature value with the largest amplitude among two adjacent points;

[0174] max: Takes the maximum value window by window, possessing local invariance;

[0175] f′ b,c,2n The element at index (b,c,2n) of the activated feature tensor F' corresponds to the first time point of the pooling window;

[0176] f′ b,c,2n+1 The element at index (b,c,2n+1) of F' corresponds to the second time point 1 in the same window;

[0177] 2n: The starting index of the pooling window in the original length dimension (step = 2);

[0178] 2n+1: The next index in the same window, which together with 2n forms a window of length 2;

[0179] The output time index range, the original length L is reduced to [value] after pooling with a step of 2. Therefore, there are a total of There are several pooling positions, and the last index is...

[0180] The time dimension is halved because stride = 2;

[0181] H1: The output tensor of the MaxPool(2) layer, which pools the max-pooling results with a stride of 2 as input to subsequent networks.

[0182] 2.3 The output is used in subsequent steps. This tensor will be fed into the second MADConv stage to achieve multi-scale feature extraction at a higher level:

[0183]

[0184] in:

[0185] B: batch size, the number of samples processed in parallel during a single forward propagation;

[0186] 32: The number of channels for the feature, derived from the output channels of the previous layer MADConv-1;

[0187] The time dimension length, the original length L, is reduced to [a value] after pooling with a step size of 2.

[0188] 3. Second-level multidimensional adaptive convolution (MADConv-2) → ReLU → MaxPool(2)

[0189] Input tensor: from the pooling output of step two.

[0190] 3.1 Multi-scale convolution

[0191] 3.1.1 Set of convolution kernels:

[0192]

[0193] in:

[0194] The m-th kernel weight tensor in the second-level convolutional group;

[0195] C in Input channel number 32;

[0196] C out Number of output channels: 64;

[0197] k m : Kernel length (3, 5, 7).

[0198] 3.1.2 Three-branch convolution

[0199]

[0200] in:

[0201] *: One-dimensional convolution operation (same-padding, output length remains unchanged);

[0202] G m Convolution outputs features, dimensions

[0203] 3.1.3 Weight Normalization

[0204]

[0205] in:

[0206] After normalization, the scaling factor used in the m-th convolutional branch of the second-level multi-scale convolution satisfies the following condition:

[0207] The original learnable scalar weights (unnormalized) represent the importance of the 2nd level and the mth convolutional kernel, and are updated by backpropagation during training;

[0208] The summation operator iterates through all three convolutional branches with index j ranging from 1 to 3.

[0209] The original weight of the j-th branch appearing in the summation, and Synonymous, except the index variable is j;

[0210] 3.1.4 Weighted Fusion

[0211]

[0212] in:

[0213] G: The weighted sum of the three-scale convolution results, which is used as the output of this level of convolution;

[0214] The summation operator, with indices m taking values ​​of 1, 2, and 3, sums up the results for each of the three convolutional branches.

[0215] After normalization, the scaling factor used in the m-th convolutional branch of the second-level multi-scale convolution satisfies the following condition:

[0216] G m The output feature of the m-th convolutional branch 1 is determined by the kernel length k. m Convolution ∈{3, 5, 7} The result is obtained by applying the action to input H1;

[0217] 3.2 ReLU Activation

[0218] G′=σ(G),σ(z=max(0,z)

[0219] z: any element g in G b,c,n ;

[0220] σ(·): ReLU, clears negative numbers to zero, and is identical to positive numbers;

[0221] G′: Tensor after activation, size remains unchanged.

[0222] 3.3 MaxPool1d(2) downsampling

[0223]

[0224] in:

[0225] g′ b,c,2n ,g′ b,c,2n+1 : The value of G′ at two adjacent time points (step size = 2);

[0226] max{·,·}: retrieves the maximum value of two points locally;

[0227] q b,c,n : The pooled cell represents the peak value of the window (2n, 2n+1);

[0228] 3.4 Output and significance of this step (Step 3)

[0229] Output tensor: H2 will be used as input to the 3rd level MADConv-3.

[0230] effect:

[0231] 1. Capture richer features through adaptive multi-scale convolution from 32 to 64;

[0232] 2. ReLU injection of nonlinearity;

[0233] 3. Pooling again halves the temporal resolution, expands the subsequent receptive field, and reduces the computational load;

[0234] 4. Level 3 Multidimensional Adaptive Convolution (MADConv-3) → ReLU → Adaptive Global Average Pooling (GAP), as follows: Figure 3 As shown.

[0235] Input tensor (from the output in step 3):

[0236] 4.1 Level 3 Multiscale Convolution

[0237] 4.1.1 Convolution Kernel Set

[0238]

[0239] in:

[0240] The m-th convolutional kernel weight tensor of level 3;

[0241] C in Number of input channels = 64;

[0242] C out Number of output channels = 128;

[0243] k m : Core length (3 / 5 / 7).

[0244] 4.1.2 Three-branch convolution

[0245]

[0246] in:

[0247] *: One-dimensional convolution operation (same padding, keeping the output length unchanged);

[0248] R m Branch convolution output, dimension

[0249] The m-th convolutional kernel weight tensor of level 3.

[0250] 4.1.3 Weight Normalization

[0251]

[0252] in:

[0253] Level 3 original weights (learnable scalars);

[0254] Normalized weights,

[0255] The sign for summation over j = 1, 2, 3.

[0256] 4.1.4 Weighted Fusion

[0257]

[0258] in:

[0259] R: The feature tensor obtained by linearly combining the three-branch outputs according to their weights.

[0260] 4.2 ReLU Activation

[0261] R′=σ(R),σ(z=max(0,z)

[0262] in:

[0263] z: any element r in R b,c,n ;

[0264] σ(z): ReLU function, negative values ​​are set to 0, positive values ​​remain unchanged;

[0265] R′: The activated tensor, with the dimension unchanged (B, 128, L2).

[0266] 4.3 Adaptive Global Average Pooling (GAP)

[0267]

[0268] in:

[0269] r′ b,c,n : Element in R′, the b-th sample, the c-th channel, and the position n;

[0270] Calculate the arithmetic mean along the time dimension for all L2 positions;

[0271] L2: Length of the sequence after pooling in step 3;

[0272] s b,c : GAP output scalar, the global average value of the b-th sample and the c-th channel.

[0273] All s b,c Reshaping into a tensor:

[0274]

[0275] 4.4 Overview of the function of this step (Step Four)

[0276] 1. Multi-scale convolution: Capture 3 / 5 / 7 receptive field features again at 64→128 channels;

[0277] 2. Adaptive weighting: The most valuable convolutional branch is automatically determined during training;

[0278] 3. ReLU: Introduces nonlinearity and suppresses unwanted negative activation;

[0279] 4. GAP: Global convergence of the time axis generates a 128-dimensional global descriptor of length 1, which can suppress noise and reduce subsequent calculations.

[0280] 5. Output H3(B,128,L3) and then feed it into the self-attention module in step five.

[0281] 5. Self-Attention mechanism (128 channels → 128 channels, the number of channels does not change, only the weighting within each channel is recalculated), (e.g.) Figure 4 (As shown).

[0282] Input tensor: H3(B,128,L3)

[0283] 5.1 Query / Key / Value Linear Projection

[0284]

[0285] in:

[0286] W Q W K W V These three are the learned 1×1 convolutional kernel weights, used to project the input tensor H3 onto the Query, Key, and Value spaces. Each weight matrix has a dimension of 128×128×1, which means that each input channel is mapped to the output channel.

[0287] H3: Input tensor, from the GAP output of step four, with a shape of B×128×L3, representing the 128-channel features of each sample;

[0288] *: Represents one-dimensional convolution. Same padding ensures that the time dimension L3 of the output tensor is the same as that of the input.

[0289] Q, K, V: Query, Key, Value represent three different representations obtained from the input tensor after convolution projection, and their shapes are B×128×L3.

[0290] 5.2 Calculate attention weights

[0291] 5.2.1 Transposition Preparation

[0292]

[0293] in:

[0294] Q T Transpose the channel dimension and time dimension of the Query tensor to obtain a matrix with dimension B×L3×128;

[0295] K: Key tensor, with shape B×128×L3, used to calculate the correlation with the Query tensor;

[0296] 5.2.2 Similarity Matrix

[0297]

[0298] in:

[0299] S: Similarity matrix, obtained through batch matrix multiplication Q T K is calculated to have a shape of B×1×1, representing the correlation of each time step with other time steps.

[0300] 5.2.3 Softmax Normalization

[0301]

[0302] in:

[0303] α b,t,t′ Attention weights represent the weight of the b-th sample between time step t and time step t'. After Softmax normalization, the resulting weights determine the influence of each time step on the output in the final weighted summation. The normalized weight values ​​range from [0,1], and for each t, ​​the sum of the weights of all t' is 1.

[0304] S b,t,t′ These are the elements in the similarity matrix S, representing the similarity between the b-th sample at time position t and time position t'. The shape is B×L3×L3, representing the correlation between each sample at different time steps.

[0305] exp(S b,t,t′ The exponential function is applied to each element in the similarity matrix, which amplifies larger similarity values ​​and increases their corresponding weights. This is to highlight time steps with strong correlations.

[0306] The normalization factor is the sum of the exponential similarities of all possible time steps j at the same time step t, ensuring that the sum of all weights is 1. This step ensures the normalization of Softmax, making the total sum of weights equal to 1, thereby guaranteeing the stability of the model.

[0307] For each time step t, the sum of the attention weights for all time steps t' is 1, and the normalized weight α for each time step is... b,t,t′ , which represents the degree of attention that time step t pays to time step t', and its value is between 0 and 1, and the sum is 1;

[0308] α: Attention weight matrix, which is softmax normalized to the similarity matrix S.

[0309] 5.3 Output obtained by weighted aggregation

[0310] H4=(αV T ) T

[0311] in:

[0312] H4: The weighted aggregation result, with a shape of B×128×L3, is obtained by applying attention weights (α) to the transpose of the Value tensor (V);

[0313] αV T Attention-weighted summation: The Value tensor at each time step is summed according to the attention weights.

[0314] V T : Transpose the Value tensor so that its dimensions change from B×L3×128 to B×128×L3.

[0315] 5.4 Overview of the functions of this step (Step 5)

[0316] 1×1 projection (convolution): Keeps the number of time steps constant, maps the input features to the Query / Key / Value space;

[0317] Attention mechanism: Calculate similarity based on query and key to obtain dynamic weights, and control the weighting of values;

[0318] Softmax: Normalizes the similarity matrix so that the sum of the attention weights of each time step to other time steps is 1.

[0319] 6. Local-global convolutional fusion (e.g.) Figure 5 (As shown)

[0320] Input tensor:

[0321] 6.1 Parallel Convolution

[0322] Convolution kernel set:

[0323]

[0324] in:

[0325] W loc Local convolutional kernel weights, with a kernel length of 3;

[0326] W glo : Global convolutional kernel weights, with a kernel length of 7;

[0327] 128: The number of input and output channels, representing the feature dimension of each sample in this layer;

[0328] 3, 7: The length of the convolution kernel. Local convolution uses a smaller receptive field (3), while global convolution uses a larger receptive field (7).

[0329] Convolution operation:

[0330]

[0331] in:

[0332] *: One-dimensional convolution operation, same padding ensures that the output length L4 remains unchanged;

[0333] H loc Local convolution output, with shape B×128×L4;

[0334] H glo : Global convolution output, with a shape of B×128×L4.

[0335] 6.2 Weighted Fusion

[0336] H5 = H loc +H glo

[0337] in:

[0338] H5: The weighted fusion output, with a shape of B×128×L4, represents the result obtained by adding the local convolution output and the global convolution output element by element;

[0339] +: Addition operation, which sums the outputs of local convolution and global convolution element by element, combining information from two different receptive fields, thereby simultaneously extracting detailed information (local convolution) and overall information (global convolution).

[0340] 6.3 ReLU Activation

[0341] R5 = ReLU(H5)

[0342] in:

[0343] R5: The activated tensor has the same shape as the input tensor and has dimensions of B×128×L4.

[0344] ReLU: Activates the input element by element, setting negative numbers to zero and positive numbers unchanged.

[0345] 6.4 MaxPool1d downsampling

[0346] H6 = MaxPool1d(2)(R5)

[0347] in:

[0348] MaxPool1d(2): One-dimensional max pooling with a pooling window size of 2 and a step size of 2;

[0349] H6: The output after pooling has its time dimension compressed to L4 / 2, reducing the time resolution and computational cost.

[0350] 6.5 Overview of the functions of this step (Step Six)

[0351] Local and global convolution: Simultaneously capture fine-grained local features and large-scale global features using different convolution kernels (3 and 7);

[0352] Weighted fusion: It fuses local and global features element by element to enhance the model's ability to represent features at multiple scales;

[0353] ReLU activation: Introduces nonlinearity, suppresses negative activation, and improves the model's expressive power;

[0354] Max pooling: Compresses the time dimension, reducing subsequent computation while preserving key features.

[0355] Output H6: The final output tensor shape is B×128×L6.

[0356] 7. Dynamic Pooling (e.g., Figure 6 (As shown)

[0357] Input tensor:

[0358] 7.1 Randomly determine the pooling window size

[0359] k~u{2,3}

[0360] in:

[0361] k: The size of the pooling window, randomly selected from {2,3}. This introduces randomness, increases the robustness of the model, and avoids overfitting.

[0362] u{2,3}: Uniformly sample from the set {2,3}, i.e. randomly select 2 or 3 as the size of the pooling window.

[0363] 7.2 Pooling Operations

[0364]

[0365] in:

[0366] H6: Input tensor, from the output of step 6, with a shape of B×128×L6;

[0367] H7: The output after pooling, with the following shape.

[0368] b: Number of sample batches;

[0369] c: Number of feature channels;

[0370] t: time step, the time step size after pooling;

[0371] k: Pooling window size, randomly selected from {2,3}, representing the window length for each pooling operation;

[0372] kt+i: The index of each time position within the window, where t is the starting position of the pooling window and i is the relative position (within the pooling window).

[0373] 7.3 Overview of the functions of this step (Step Seven)

[0374] The final pooling output has the following shape: This indicates that the time dimension of the features, after dynamic pooling, is reduced by the pooling operation, and the length changes from L6 to... The size of the feature after pooling depends on the size k of the pooling window;

[0375] Dynamic pooling: Randomly selects a window of different size during each pooling operation to enhance the model's generalization ability and robustness;

[0376] Pooling window: Use k=2 or 3 to adjust the time dimension, reduce the amount of computation, and retain the most important feature information;

[0377] Temporal compression: Pooling reduces the number of time steps, decreases computation, and expands the receptive field.

[0378] 8. Flattening + Linear Classification (Flatten → FC → Softmax)

[0379] Input tensor:

[0380] 8.1 Flattening Operation

[0381]

[0382] in:

[0383] H7: Input tensor, with shape B×128×L7, from the pooling result in step 7;

[0384] The flattened tensor, each sample is flattened into a one-dimensional vector with a shape of 128×L7, that is, all channels and time steps of each sample are merged into a long vector;

[0385] reshape: Flattening operation, compressing a multidimensional tensor into one dimension;

[0386] [128×L7]: The output dimension after flattening, i.e., 128×L7.

[0387] 8.2 Fully Connected Layer (Linear Mapping)

[0388]

[0389] in:

[0390] Z b,j : logit, the predicted score of the b-th sample for the j-th class, with shape B×N cls ;

[0391] The c-th element in the flattened eigenvector comes from the flattened eigenvector.

[0392] W c,j The weights of the fully connected layer have a shape of [128×L7×N]. cls ] represents the range from 128×L7 dimensions to the number of categories N. cls Mapping;

[0393] b j : Bias term, corresponding to the j-th class, with shape [N cls ];

[0394] N cls : Number of categories, indicating the number of categories to be output.

[0395] 8.3 Softmax Normalization (Output Probability)

[0396]

[0397] in:

[0398] P b,j The Softmax output represents the probability that the b-th sample belongs to the j-th class, and has a shape of B×N. cls ;

[0399] exp(Z b,j): Apply an exponential function to the predicted score (logit) for each category to enhance the model's preference for high-scoring categories;

[0400] Sum the index scores for all categories and normalize them to ensure that the sum of the probabilities for all categories is 1.

[0401] Please see Figure 7 The diagram shows a structural block diagram of a wind turbine gearbox fault detection system according to this application.

[0402] like Figure 7 As shown, the wind turbine gearbox fault detection system 200 includes an acquisition module 210, a training module 220, and an output module 230.

[0403] The acquisition module 210 is configured to acquire gearbox vibration signals and preprocess the gearbox vibration signal sequence to obtain at least one gearbox vibration sub-signal and a gearbox state corresponding to the at least one gearbox vibration sub-signal; the training module 220 is configured to input the at least one gearbox vibration sub-signal sequence and the corresponding gearbox state into a preset GearFaultNet network and iteratively train the GearFaultNet network to obtain a gearbox fault detection model; the output module 230 is configured to input the acquired real-time gearbox vibration signal into the gearbox fault detection model, and the gearbox fault detection model outputs a gearbox fault state corresponding to the real-time gearbox vibration signal.

[0404] It should be understood that Figure 7 The modules and references described in the document Figure 1 The steps described in the text correspond to those in the method described above. Therefore, the operations, features, and corresponding technical effects described above also apply to the method described in the text. Figure 7 The various modules in the document will not be described in detail here.

[0405] In other embodiments, the present invention also provides a computer-readable storage medium having a computer program stored thereon, wherein when the program instructions are executed by a processor, the processor performs the wind turbine gearbox fault detection method in any of the above method embodiments.

[0406] In one embodiment, the computer-readable storage medium of the present invention stores computer-executable instructions, which are configured as follows:

[0407] The gearbox vibration signal is acquired, and the gearbox vibration signal sequence is preprocessed to obtain at least one gearbox vibration sub-signal and the gearbox state corresponding to the at least one gearbox vibration sub-signal.

[0408] The at least one gearbox vibrating sub-signal sequence and the corresponding gearbox state are input into a preset GearFaultNet network, and the GearFaultNet network is iteratively trained to obtain a gearbox fault detection model.

[0409] The acquired real-time gearbox vibration signal is input into the gearbox fault detection model, and the gearbox fault detection model outputs the gearbox fault state corresponding to the real-time gearbox vibration signal.

[0410] Computer-readable storage media may include a stored program area and a stored data area, wherein the stored program area may store an operating system and an application program required for at least one function; the stored data area may store data created based on the use of the wind turbine gearbox fault detection system, etc. Furthermore, the computer-readable storage medium may include high-speed random access memory, and may also include memory, such as at least one disk storage device, flash memory device, or other non-volatile solid-state storage device. In some embodiments, the computer-readable storage medium may optionally include memory remotely configured relative to a processor, which can be connected to the wind turbine gearbox fault detection system via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0411] Figure 8 This is a schematic diagram of the structure of the electronic device provided in the embodiment of the present invention, such as... Figure 8 As shown, the device includes a processor 310 and a memory 320. The electronic device may also include an input device 330 and an output device 340. The processor 310, memory 320, input device 330, and output device 340 can be connected via a bus or other means. Figure 8 Taking a bus connection as an example, the memory 320 is the computer-readable storage medium described above. The processor 310 executes various server functions and data processing by running non-volatile software programs, instructions, and modules stored in the memory 320, thereby implementing the wind turbine gearbox fault detection method described in the above embodiment. The input device 330 can receive input digital or character information and generate key signal inputs related to user settings and function control of the wind turbine gearbox fault detection system. The output device 340 may include a display screen or other display device.

[0412] The aforementioned electronic device can execute the method provided in the embodiments of the present invention, and has the corresponding functional modules and beneficial effects for executing the method. Technical details not described in detail in this embodiment can be found in the method provided in the embodiments of the present invention.

[0413] In one implementation, the above-described electronic device is applied to a wind turbine gearbox fault detection system for a client application, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to:

[0414] The gearbox vibration signal is acquired, and the gearbox vibration signal sequence is preprocessed to obtain at least one gearbox vibration sub-signal and the gearbox state corresponding to the at least one gearbox vibration sub-signal.

[0415] The at least one gearbox vibrating sub-signal sequence and the corresponding gearbox state are input into a preset GearFaultNet network, and the GearFaultNet network is iteratively trained to obtain a gearbox fault detection model.

[0416] The acquired real-time gearbox vibration signal is input into the gearbox fault detection model, and the gearbox fault detection model outputs the gearbox fault state corresponding to the real-time gearbox vibration signal.

[0417] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., including several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods of various embodiments or some parts of embodiments.

[0418] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for detecting faults in a wind turbine gearbox, characterized in that, include: The gearbox vibration signal is acquired, and the gearbox vibration signal sequence is preprocessed to obtain at least one gearbox vibration sub-signal and the gearbox state corresponding to the at least one gearbox vibration sub-signal. The at least one gearbox vibrating sub-signal sequence and the corresponding gearbox state are input into a preset GearFaultNet network, and the GearFaultNet network is iteratively trained to obtain a gearbox fault detection model. The acquired real-time gearbox vibration signal is input into the gearbox fault detection model, and the gearbox fault detection model outputs the gearbox fault state corresponding to the real-time gearbox vibration signal.

2. The method for detecting faults in a wind turbine gearbox according to claim 1, characterized in that, The preprocessing of the gearbox vibration signal sequence to obtain at least one gearbox vibration sub-signal, and the gearbox state corresponding to the at least one gearbox vibration sub-signal, includes: The gearbox vibration signal is segmented to obtain multiple gearbox vibration sub-signals of fixed length, expressed as follows: x i =[x[i·S],x[i·S+1],...,x[i·S+L-1]], In the formula, x i This is the signal of the i-th gearbox resonator. Each gearbox vibrating sub-signal is assigned a corresponding label based on the actual gearbox state, thus obtaining the gearbox state corresponding to the at least one gearbox vibrating sub-signal sequence. The expression for assigning the corresponding label is as follows: In the formula, y i This is the label corresponding to the i-th gearbox resonator signal.

3. The method for detecting faults in a wind turbine gearbox according to claim 1, characterized in that, The step of inputting the at least one gearbox vibrating sub-signal sequence and the corresponding gearbox state into a preset GearFaultNet network, and iteratively training the GearFaultNet network to obtain a gearbox fault detection model includes: The gearbox vibrating sub-signal is processed by a multidimensional adaptive convolution module, which uses multiple convolution kernel sizes to extract features at different scales to obtain the first output feature. The first output feature is then subjected to nonlinear transformation and feature compression by the ReLU activation function and MaxPool1d pooling layer to obtain the second output feature. The second output feature is extracted through a multidimensional adaptive convolutional layer to obtain a third output feature, and the third output feature is input into a self-attention mechanism module, which outputs a fourth output feature. The fourth output feature is sequentially input into the local convolution module and the global convolution module, and local features and global features are output respectively. The local features and global features are then fused through the local and global convolution joint learning module to obtain the fifth output feature. The fifth output feature is pooled by the dynamic pooling module to obtain the sixth output feature, and the final detection result is output by the classifier. The loss is calculated by the adaptive weighted cross-entropy loss function, and the model is trained by backpropagation to obtain the gearbox fault detection model.

4. The method for detecting faults in a wind turbine gearbox according to claim 3, characterized in that, The expression for the adaptive weighted cross-entropy loss function is: In the formula, The adaptive weighted cross-entropy loss function is... This represents the averaging operation, which calculates the average across all samples in the batch, ensuring that the loss is independent of the sample size. B represents the number of samples processed in the next forward propagation. This means summing the losses for each sample b in the batch, calculating the loss for each sample, and then averaging the sums to obtain the loss for the entire batch. This represents summing over all classes j to calculate the loss for each sample across all classes, N. cls w represents the number of possible classes in the model's classification task. j y represents the weight of class j. b,j Let b be the true label of the b-th sample in class j, log(P) b，j To perform a logarithmic transformation on the predicted probability, P b,j Let be the predicted probability of the b-th sample in class j, freq(j) be the frequency of class j in the training set, ∈ be a minimal constant used to avoid division by zero error, and exp(Z) be the predicted probability of the b-th sample in class j. b，j To apply the exponential function to the predicted score of category j, Sum the index scores for all categories, then normalize them to ensure that the sum of the probabilities for all categories is 1.

5. The method for detecting faults in a wind turbine gearbox according to claim 3, characterized in that, The process of extracting features from the second output features via a multidimensional adaptive convolutional layer to obtain the third output features includes: Based on the first convolution kernel, the second output feature is convolved for the first time to obtain the first output sub-feature; Based on the second convolution kernel, the second output feature is convolved a second time to obtain the second output sub-feature; Based on the third convolution kernel, the third output feature is convolved a third time to obtain the third output sub-feature; The first output sub-feature, the second output sub-feature, and the third output sub-feature are weighted and fused to obtain the third output feature.

6. The method for detecting faults in a wind turbine gearbox according to claim 3, characterized in that, The process of performing a pooling operation on the fifth output feature using the dynamic pooling module to obtain the sixth output feature includes: A pooling window size is randomly determined, and a pooling operation is performed on the fifth output feature according to the pooling window size to obtain the sixth output feature. The expression for the pooling operation is as follows: In the formula, H6 is the fifth output feature, H7 is the sixth output feature, b is the number of sample batches, c is the number of feature channels, t is the time step after pooling, k is the pooling window size, randomly selected from {2,3}, representing the window length of each pooling operation, kt+i is the index of each time position within the window, t is the starting position of the pooling window, and i is the relative position.

7. A wind turbine gearbox fault detection system, characterized in that, include: The acquisition module is configured to acquire gearbox vibration signals and preprocess the gearbox vibration signal sequence to obtain at least one gearbox vibration sub-signal and a gearbox state corresponding to the at least one gearbox vibration sub-signal. The training module is configured to input the at least one gearbox vibrating sub-signal sequence and the corresponding gearbox state into a preset GearFaultNet network, and to iteratively train the GearFaultNet network to obtain a gearbox fault detection model. The output module is configured to input the acquired real-time gearbox vibration signal into the gearbox fault detection model, and the gearbox fault detection model outputs the gearbox fault state corresponding to the real-time gearbox vibration signal.

8. An electronic device, characterized in that, include: At least one processor, and a memory communicatively connected to the at least one processor, wherein the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method according to any one of claims 1 to 6.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by a processor, it implements the method described in any one of claims 1 to 6.

Images