A machine learning-based fastener fatigue life prediction method

Abstract

The application discloses a kind of fastener fatigue life prediction methods based on machine learning, comprising the following steps: S1, acquisition and pre-processing fastener operation monitoring data;S2, sliding window and extract fusion feature vector;S3, construct time series correlation diagram based on feature difference;S4, perform multi-branch graph feature aggregation to generate embedding tensor;S5, expand graph embedding and perform recursive modeling to output degradation representation;S6, piecewise fitting degradation curve to predict remaining life;S7, align predicted value to generate fatigue warning result.The application realizes high-precision dynamic prediction and real-time early warning of fastener fatigue life, with the technical advantages of accurate modeling, fast response and wide operating condition adaptation.

Description

Technical Field

[0001] This invention relates to the field of machine learning technology, and in particular to a method for predicting the fatigue life of fasteners based on machine learning. Background Technology

[0002] Fasteners, as crucial components connecting mechanical structures and transmitting loads, are highly susceptible to fatigue damage under long-term and repeated loads, thus affecting the structural safety and operational stability of the overall equipment. Predicting the fatigue life of fasteners has always been a key research topic in fields such as mechanical manufacturing, aerospace, and energy equipment. Traditional fatigue life assessment methods typically rely on methods such as the SN curve method based on experimental data fitting, the Miner linear accumulation method, or fracture mechanics methods based on stress intensity factors. These methods are often based on ideal operating conditions and cannot accurately characterize the multi-factor influence of complex load paths, environmental disturbances, and nonlinear material responses during actual use, leading to potential biases in the prediction results.

[0003] With the development of the Industrial Internet of Things (IIoT) and sensing technology, more and more industrial equipment has achieved real-time acquisition and recording of multiple physical quantities such as stress, vibration, temperature, and load. Fatigue life prediction methods based on this multi-source time-series data have gradually attracted attention. Some studies have attempted to introduce time series analysis and statistical learning methods into fatigue modeling, using regression analysis or probabilistic models to model the fatigue evolution process. However, these methods often use local features or single indicators as input, lacking the ability to systematically model the temporal correlations between multi-dimensional features. They struggle to fully capture cross-scale change patterns in the degradation process, resulting in low modeling accuracy and poor real-time performance.

[0004] In recent years, machine learning techniques, especially deep learning, have demonstrated significant advantages in industrial forecasting tasks, automatically learning the nonlinear mapping relationship between features and outputs through end-to-end modeling. Some studies have introduced models such as convolutional neural networks and recurrent neural networks to process structural health monitoring data for predicting remaining life. However, existing techniques often overlook the combined characteristics of time-series dependence, stage-specific features, and local abrupt changes in fastener fatigue degradation, and lack modeling of graph-structure dependencies between multi-source signals, failing to fully explore the potential connection between load response and damage evolution.

[0005] Furthermore, most current fatigue life prediction models do not incorporate novel learning frameworks such as graph neural networks and structural attention mechanisms that can model complex temporal topological relationships, resulting in insufficient capture of microscopic trends in the fatigue evolution process. At the same time, the degradation process has distinct stage-specific characteristics; if each stage is not modeled and processed separately, problems such as concentrated fitting errors and unstable remaining life estimation are easily encountered, making it difficult to meet the dual requirements of prediction accuracy and response speed in industrial settings.

[0006] Therefore, how to provide a fastener fatigue life prediction method based on machine learning is a problem that urgently needs to be solved by those skilled in the art. Summary of the Invention

[0007] One objective of this invention is to propose a fastener fatigue life prediction method based on machine learning. This invention fully utilizes technologies such as multi-source monitoring data processing, graph structure modeling, structural attention mechanism and recursive modeling, and describes in detail the entire process of fatigue degradation trend modeling and remaining life prediction under the GPU parallel computing framework. It has the advantages of high modeling accuracy, fast response speed and adaptability to multiple working conditions.

[0008] A fastener fatigue life prediction method based on machine learning according to an embodiment of the present invention includes the following steps:

[0009] S1. Collect monitoring data of fasteners during operation and perform preprocessing;

[0010] S2. Divide the monitoring data into a sliding window of fixed length, and perform wavelet packet decomposition, spectral entropy analysis and deformation rate calculation to generate a feature vector set that integrates frequency domain features, statistical features and waveform features.

[0011] S3. Construct a time-series correlation graph based on the feature vector set, using the feature vector corresponding to the sliding window as the graph node, and generating weighted edges based on the stress change rate, vibration energy difference, and load amplitude difference of adjacent nodes.

[0012] S4. Based on the temporal correlation graph, perform neighborhood aggregation based on diffusion kernel, node reweighting based on structural attention, and feature interaction based on cross-scale mapping respectively, and merge the graph embedding tensors generated by each branch.

[0013] S5. Expand the graph embedding tensor along the time index, perform recursive modeling and parameter backpropagation based on unidirectional causal constraints, and generate a set of degenerate representations that characterize the trend of damage evolution.

[0014] S6. Perform multi-segment dynamic regression modeling on the degradation representation set, and fit the degradation curves of the initial slow-change stage, the middle stable stage and the final accelerated stage respectively. Calculate the remaining lifetime prediction value based on the curve change rate.

[0015] S7. Align the remaining life prediction value with the time index, set threshold conditions and combine them with strategy optimization logic to judge the fatigue state, and output the life risk warning result of the fastener.

[0016] Optionally, the monitoring data is synchronously acquired through stress sensors, acceleration sensors, and load sensors installed near the fasteners. The monitoring data includes axial stress, lateral vibration, cyclic load, and temperature signals. The preprocessing includes time alignment, signal denoising, outlier removal, and numerical normalization of the monitoring data to output a standardized monitoring sequence. The strategy optimization logic refers to dynamically adjusting the warning level and maintenance response strategy based on the remaining life prediction results and preset thresholds to achieve risk minimization and optimal resource scheduling.

[0017] Optionally, S2 specifically includes:

[0018] S21. Divide the standardized monitoring sequence into sliding time windows of equal length according to the time axis, set the offset step size between each window, record the start and end index of each window during the sliding process, and form a monitoring segment sequence arranged in chronological order.

[0019] S22. For each monitoring segment, the Daubechies wavelet basis function with symmetrical support structure is used to perform layer-by-layer wavelet packet decomposition on the GPU to extract the energy values ​​corresponding to all sub-bands. The energy ratio of each sub-band is recorded in the GPU shared memory as a frequency domain feature vector reflecting the frequency domain distribution characteristics of the signal.

[0020] S23. For the axial stress signal and transverse vibration signal in each monitoring segment, perform spectral entropy analysis in the GPU, specifically including:

[0021] The original signal data block is loaded into the local buffer, and a fast Fourier transform operation is performed to extract the spectrum data. After the spectrum amplitude is normalized, the frequency probability density distribution is calculated according to the frequency distribution. Based on the frequency probability density, the spectral entropy value is calculated in parallel on the GPU.

[0022] The mean difference and variance of adjacent sample pairs are calculated on the original signal, a multidimensional embedding vector is constructed, and similarity statistics are performed on the vector sequence to output the sample entropy value.

[0023] The original signal is normalized to zero mean, and the ratio between the peak value deviating from zero mean and the waveform stretching amplitude is calculated as the kurtosis index. Finally, the three results of spectral entropy, sample entropy and kurtosis are merged and stored in the statistical feature vector to characterize the frequency complexity and time domain variation characteristics of the signal in the current window.

[0024] S24. Using the central difference method, perform batch difference processing on the stress sequence in each monitoring segment on the GPU, calculate the stress change rate at each time point, extract the maximum change rate, average change rate and standard deviation in sequence, combine the three results into a deformation rate feature vector, and use a memory-shared structure to stitch it into the monitoring segment.

[0025] S25. The frequency domain features, statistical features and deformation rate features corresponding to each monitoring segment are structurally spliced ​​in the global memory of the GPU to generate a fusion vector after merging the three types of features, and uniformly numbered according to time order to form a feature vector set.

[0026] Optionally, the frequency domain feature extraction process specifically includes:

[0027] For each monitoring segment within a sliding window, the normalized axial stress signal is loaded into the GPU's global memory. The CUDA kernel function is then called to perform a layer-by-layer wavelet packet decomposition operation on the signal. Each layer uses the Daubechies wavelet basis function to construct a filter bank. High-pass and low-pass filtering is performed on the signal in parallel using GPU threads. The filtering results are downsampled to generate the sub-band signal of the current layer. The energy of all sub-band signals is summed by squaring point by point to obtain the energy value of each frequency band. The sum of the energy values ​​of each frequency band is then calculated in the GPU register, and the energy value of each frequency band is normalized according to a preset ratio. The normalized energy distribution constitutes a frequency domain feature vector. The vector result is written to the local buffer through the GPU device memory, completing the extraction of the frequency domain features of the current window.

[0028] Optionally, S3 specifically includes:

[0029] S31. Arrange the feature vector set in chronological order, set each feature vector to correspond to a graph node, and connect adjacent feature vectors in sequence according to the sliding window order to form a set of node pairs, which serves as the initial skeleton of the time series graph structure.

[0030] S32. For each pair of adjacent nodes, extract the stress change rate index from the corresponding feature vector, calculate the difference between the maximum stress value of the next node and the maximum stress value of the previous node, and write the difference into the stress channel of the edge feature matrix on the GPU. The stress channel is constructed by calculating the difference between the maximum stress values ​​in adjacent sliding windows.

[0031] S33. Extract vibration energy index from the corresponding feature vector, calculate the sum of wavelet decomposition subband energy in the two nodes respectively, calculate the absolute value of their difference, and form the vibration energy difference of the edge feature matrix. Shared memory is used to avoid repeated memory access. The vibration energy difference is determined based on the difference of the sum of wavelet packet decomposition energy of adjacent nodes.

[0032] S34. Extract the maximum amplitude of the cyclic load from the feature vector set, calculate the difference in load amplitude between adjacent nodes, assign the result to the load channel of the edge feature matrix, and use a multi-threaded structure to perform parallel calculations on all node pairs and write them into the edge feature matrix.

[0033] S35. Perform uniform weighting processing on the edge feature matrix on the GPU, set a fixed weight coefficient template, use GPU vector multiplication to calculate the weight value of each edge, output the edge weight matrix, and combine the node set with the edge weight matrix to construct the completed temporal correlation graph.

[0034] Optionally, S4 specifically includes:

[0035] S41. Perform a neighborhood aggregation operation based on the diffusion kernel on the temporal correlation graph:

[0036] Read the edge weight vector corresponding to each node, build a node adjacency table in shared memory, set the propagation step size and neighborhood range according to the diffusion kernel model, use sparse matrix multiplication to realize the transfer and fusion of node features between adjacent nodes, obtain the neighborhood aggregation tensor, and cache the neighborhood aggregation features of each node in the local buffer.

[0037] S42. Perform a node reweighting process based on structural attention for each node in the temporal correlation graph:

[0038] Load the feature vectors of each graph node and all its neighboring nodes into the GPU global memory, and concatenate the node's own features with the features of each neighboring node according to the channel dimension to generate a node pair feature sequence.

[0039] The CUDA parallel kernel function is called to perform dot product operation on all node pairs, and the structural similarity weights are calculated in combination with the learnable query vectors. The weight vectors corresponding to each node are stored in shared memory.

[0040] For each node, the feature vectors of all its neighboring nodes are summed according to their corresponding weights to form the reweighted feature representation of the current node. Finally, the reweighted feature vectors of all nodes are merged to generate the structural reweighted feature tensor.

[0041] S43. Perform cross-scale mapping on the neighborhood aggregation tensor and the structure-reweighted feature tensor:

[0042] A scale grouping scheme is set up to divide each feature tensor into multiple scale segments according to the channel dimension. Convolutional channel compression operation is used to unify the dimension of each scale segment, and the multi-scale segments are merged in the GPU through a stitching operation to construct a cross-scale interactive tensor.

[0043] S44. The neighborhood aggregation tensor, the structural reweighted feature tensor, and the cross-scale interaction tensor are fused at the channel level. The three-branch feature integration is achieved by using a parallel weighted mapping method, and the graph embedding tensor is output.

[0044] Optionally, S5 specifically includes:

[0045] S51. Expand the graph embedding tensor according to the time index of the sliding window, construct the time series tensor in the GPU global memory in a row-first manner, and ensure that the embedding vectors of adjacent windows are arranged continuously in memory. Call the custom data loader to divide the expanded embedding tensor into equal-length segments and load them into the input port of the recurrent neural network in time order.

[0046] S52. Set a one-way causal constraint mechanism, enable the one-way structure in the recurrent neural network, use the gated recurrent unit as the basic modeling unit, create an independent thread block for each time step in the CUDA kernel function, each thread reads the graph embedding vector at the current time step, extracts the historical state variables from the hidden state tensor of the previous time step, performs the gated activation function calculation in shared memory, and writes the result to the hidden state buffer after completing the hidden state update of the current time step. Only the historical state is allowed to be forward-propagated, and no information from future time steps is read.

[0047] S53. After completing the recursive modeling for all time steps, the error between the final hidden state tensor and the target degradation label is calculated. The mean squared error is used to construct the loss tensor. On the GPU, the backpropagation graph structure is enabled, and the chained differentiation process is executed. The historical states in the hidden state buffer are traversed sequentially. The shared weighted inner product kernel function is called to accumulate gradients for the network parameters. The accumulated gradients are used to update the weight matrix through the gradient descent method, and the hidden state vector corresponding to each time index is output to form a set of degradation representations used to describe the evolution trend of fatigue damage.

[0048] Optionally, S6 specifically includes:

[0049] S61. Load the set of degenerate representations into shared memory in chronological order. Use the window sliding convolution algorithm to detect the local change trend of the degenerate values. Perform batch calculations on the average slope, mean square volatility and slope change density within the sliding window on the GPU. Divide the initial slow change stage, the middle stable stage and the final acceleration stage based on the set threshold range, and record the start and end indices of each stage.

[0050] S62. Based on the start and end indices of each stage, the degenerate representation set is segmented and sliced. Local dynamic regression modeling tensors corresponding to each stage are constructed. A neural network regression model is used to perform fitting training on the three start and end indices. During the training process, an optimizer with regularization terms is used to control the network convergence speed. Forward propagation and error backpropagation operations are performed in the GPU parallel thread to complete the nonlinear modeling of the degenerate curves of each stage.

[0051] The neural network regression model is a feedforward neural network consisting of an input layer, two hidden layers, and an output layer. The input layer receives the degradation representation vector of the corresponding stage, the hidden layer extracts nonlinear features through an activation function, and the output layer generates the fitted degradation trend value. The model structure is constructed on the GPU through tensor initialization, and the weight parameters are iteratively updated by the gradient descent method.

[0052] S63. The degradation curves generated by the neural network regression model are spliced ​​together in chronological order to form a complete multi-segment degradation curve. Based on the slope of the degradation curve output in the final acceleration stage, the rate of change of degradation value and the range of stable deviation, the interpolation inverse solution operation is performed in the GPU to derive the time step required from the current moment to the termination criterion. This step step is then multiplied by the sliding window width to obtain the remaining lifetime prediction value.

[0053] The beneficial effects of this invention are:

[0054] First, this invention extracts a high-dimensional feature vector set that integrates frequency domain, statistical, and waveform features by performing wavelet packet decomposition, spectral entropy analysis, and deformation rate calculation on multi-source monitoring data of fasteners under actual operating conditions. This provides more comprehensive and accurate input data for subsequent modeling.

[0055] Secondly, based on the temporal correlation graph, a graph structure embedding model is constructed. By combining diffusion kernel neighborhood aggregation, structural attention reweighting, and cross-scale mapping feature interaction mechanism, this invention effectively models the graph structure dependency relationship between different time points in the fatigue evolution process, and significantly improves the model's sensitivity to degradation trends and subtle changes.

[0056] Finally, by using recursive modeling and multi-segment nonlinear regression methods to capture the changing patterns of the degradation process in stages, this invention achieves dynamic and precise prediction of remaining lifespan. Compared with traditional methods, it has stronger generalization ability and timeliness, and can stably output fatigue life warning results under complex working conditions. Attached Figure Description

[0057] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings:

[0058] Figure 1 This is a flowchart of a fastener fatigue life prediction method based on machine learning proposed in this invention.

[0059] Figure 2 This is a flowchart illustrating the feature extraction and graph structure construction process of a fastener fatigue life prediction method based on machine learning proposed in this invention.

[0060] Figure 3This is a flowchart illustrating the graph neural network modeling and degradation trend learning process of a fastener fatigue life prediction method based on machine learning proposed in this invention. Detailed Implementation

[0061] The present invention will now be described in further detail with reference to the accompanying drawings. These drawings are simplified schematic diagrams, illustrating only the basic structure of the invention, and therefore only show the components relevant to the invention.

[0062] refer to Figure 1-3 A method for predicting the fatigue life of fasteners based on machine learning includes the following steps:

[0063] S1. Collect monitoring data of fasteners during operation and perform preprocessing;

[0064] S2. Divide the monitoring data into a sliding window of fixed length, and perform wavelet packet decomposition, spectral entropy analysis and deformation rate calculation to generate a feature vector set that integrates frequency domain features, statistical features and waveform features.

[0065] S3. Construct a time-series correlation graph based on the feature vector set, using the feature vector corresponding to the sliding window as the graph node, and generating weighted edges based on the stress change rate, vibration energy difference, and load amplitude difference of adjacent nodes.

[0066] S4. Based on the temporal correlation graph, perform neighborhood aggregation based on diffusion kernel, node reweighting based on structural attention, and feature interaction based on cross-scale mapping respectively, and merge the graph embedding tensors generated by each branch.

[0067] S5. Expand the graph embedding tensor along the time index, perform recursive modeling and parameter backpropagation based on unidirectional causal constraints, and generate a set of degenerate representations that characterize the trend of damage evolution.

[0068] S6. Perform multi-segment dynamic regression modeling on the degradation representation set, and fit the degradation curves of the initial slow-change stage, the middle stable stage and the final accelerated stage respectively. Calculate the remaining lifetime prediction value based on the curve change rate.

[0069] S7. Align the remaining life prediction value with the time index, set threshold conditions and combine them with strategy optimization logic to judge the fatigue state, and output the life risk warning result of the fastener.

[0070] In this embodiment, the monitoring data is synchronously collected by stress sensors, acceleration sensors, and load sensors installed near the fasteners. The monitoring data includes axial stress, lateral vibration, cyclic load, and temperature signals. The preprocessing includes time alignment, signal denoising, outlier removal, and numerical normalization of the monitoring data to output a standardized monitoring sequence. The strategy optimization logic refers to dynamically adjusting the warning level and maintenance response strategy based on the remaining life prediction results and preset thresholds to achieve risk minimization and optimal resource scheduling.

[0071] In this embodiment, S2 specifically includes:

[0072] S21. Divide the standardized monitoring sequence into sliding time windows of equal length according to the time axis, set the offset step size between each window, record the start and end index of each window during the sliding process, and form a monitoring segment sequence arranged in chronological order.

[0073] S22. For each monitoring segment, the Daubechies wavelet basis function with symmetrical support structure is used to perform layer-by-layer wavelet packet decomposition on the GPU to extract the energy values ​​corresponding to all sub-bands. The energy ratio of each sub-band is recorded in the GPU shared memory as a frequency domain feature vector reflecting the frequency domain distribution characteristics of the signal.

[0074] S23. For the axial stress signal and transverse vibration signal in each monitoring segment, perform spectral entropy analysis in the GPU, specifically including:

[0075] The original signal data block is loaded into the local buffer, and a fast Fourier transform operation is performed to extract the spectrum data. After the spectrum amplitude is normalized, the frequency probability density distribution is calculated according to the frequency distribution. Based on the frequency probability density, the spectral entropy value is calculated in parallel on the GPU.

[0076] The mean difference and variance of adjacent sample pairs are calculated on the original signal, a multidimensional embedding vector is constructed, and similarity statistics are performed on the vector sequence to output the sample entropy value.

[0077] The original signal is normalized to zero mean, and the ratio between the peak value deviating from zero mean and the waveform stretching amplitude is calculated as the kurtosis index. Finally, the three results of spectral entropy, sample entropy and kurtosis are merged and stored in the statistical feature vector to characterize the frequency complexity and time domain variation characteristics of the signal in the current window.

[0078] S24. Using the central difference method, perform batch difference processing on the stress sequence in each monitoring segment on the GPU, calculate the stress change rate at each time point, extract the maximum change rate, average change rate and standard deviation in sequence, combine the three results into a deformation rate feature vector, and use a memory-shared structure to stitch it into the monitoring segment.

[0079] S25. The frequency domain features, statistical features and deformation rate features corresponding to each monitoring segment are structurally spliced ​​in the global memory of the GPU to generate a fusion vector after merging the three types of features, and uniformly numbered according to time order to form a feature vector set.

[0080] In this embodiment, the extraction process of the frequency domain features specifically includes:

[0081] For each monitoring segment within a sliding window, the normalized axial stress signal is loaded into the GPU's global memory. The CUDA kernel function is then called to perform a layer-by-layer wavelet packet decomposition operation on the signal. Each layer uses the Daubechies wavelet basis function to construct a filter bank. High-pass and low-pass filtering is performed on the signal in parallel using GPU threads. The filtering results are downsampled to generate the sub-band signal of the current layer. The energy of all sub-band signals is summed by squaring point by point to obtain the energy value of each frequency band. The sum of the energy values ​​of each frequency band is then calculated in the GPU register, and the energy value of each frequency band is normalized according to a preset ratio. The normalized energy distribution constitutes a frequency domain feature vector. The vector result is written to the local buffer through the GPU device memory, completing the extraction of the frequency domain features of the current window.

[0082] In this embodiment, S3 specifically includes:

[0083] S31. Arrange the feature vector set in chronological order, set each feature vector to correspond to a graph node, and connect adjacent feature vectors in sequence according to the sliding window order to form a set of node pairs, which serves as the initial skeleton of the time series graph structure.

[0084] S32. For each pair of adjacent nodes, extract the stress change rate index from the corresponding feature vector, calculate the difference between the maximum stress value of the next node and the maximum stress value of the previous node, and write the difference into the stress channel of the edge feature matrix on the GPU. The stress channel is constructed by calculating the difference between the maximum stress values ​​in adjacent sliding windows.

[0085] S33. Extract vibration energy index from the corresponding feature vector, calculate the sum of wavelet decomposition subband energy in two nodes respectively, calculate the absolute value of their difference, and form the vibration energy difference of the edge feature matrix. Shared memory is used to avoid repeated memory access. The vibration energy difference is determined based on the difference of the sum of wavelet packet decomposition energy of adjacent nodes, specifically including:

[0086] For each pair of adjacent nodes, two contiguous spaces are allocated in the GPU global memory to store the frequency band energy vectors of the two nodes respectively. Each frequency band energy vector contains all the sub-band energy values ​​obtained by multi-layer wavelet packet decomposition.

[0087] Each pair of nodes is assigned an independent CUDA thread. Within each thread, the sub-band energy values ​​of the current node and the previous node are read from the GPU global memory according to the frequency band index. The energy value accumulation operation is performed item by item using a sequential access strategy, and the total frequency band energy of the two nodes is calculated respectively.

[0088] The thread internally calls a fast subtraction operation instruction to calculate the difference between the two sums, and uses the square root kernel function to process the square of the difference to obtain the scalar result of the vibration energy difference;

[0089] After normalizing the vibration energy difference scalar, it is stored in a thread-shared memory structure, and the unified write function is called after all nodes have completed the calculation through the thread block synchronization mechanism.

[0090] Write the scalar results of the vibration energy difference corresponding to all node pairs into the vibration channel of the edge feature matrix. The edge feature matrix is ​​located by the node index in the numbered row and column, thus completing the batch calculation and writing of the vibration energy difference in the time series correlation graph.

[0091] S34. Extract the maximum amplitude of the cyclic load from the feature vector set, calculate the difference in load amplitude between adjacent nodes, assign the result to the load channel of the edge feature matrix, and use a multi-threaded structure to perform parallel calculations on all node pairs and write them into the edge feature matrix.

[0092] S35. Perform uniform weighting processing on the edge feature matrix on the GPU, set a fixed weight coefficient template, use GPU vector multiplication to calculate the weight value of each edge, output the edge weight matrix, and combine the node set with the edge weight matrix to construct the completed temporal correlation graph.

[0093] In this embodiment, S4 specifically includes:

[0094] S41. Perform a neighborhood aggregation operation based on the diffusion kernel on the temporal correlation graph:

[0095] Read the edge weight vector corresponding to each node, build a node adjacency table in shared memory, set the propagation step size and neighborhood range according to the diffusion kernel model, use sparse matrix multiplication to realize the transfer and fusion of node features between adjacent nodes, obtain the neighborhood aggregation tensor, and cache the neighborhood aggregation features of each node in the local buffer.

[0096] S42. Perform a node reweighting process based on structural attention for each node in the temporal correlation graph:

[0097] Load the feature vectors of each graph node and all its neighboring nodes into the GPU global memory, and concatenate the node's own features with the features of each neighboring node according to the channel dimension to generate a node pair feature sequence.

[0098] The CUDA parallel kernel function is called to perform dot product operation on all node pairs, and the structural similarity weights are calculated in combination with the learnable query vectors. The weight vectors corresponding to each node are stored in shared memory.

[0099] For each node, the feature vectors of all its neighboring nodes are summed according to their corresponding weights to form the reweighted feature representation of the current node. Finally, the reweighted feature vectors of all nodes are merged to generate the structural reweighted feature tensor.

[0100] S43. Perform cross-scale mapping on the neighborhood aggregation tensor and the structure-reweighted feature tensor:

[0101] A scale grouping scheme is set up to divide each feature tensor into multiple scale segments according to the channel dimension. Convolutional channel compression operation is used to unify the dimension of each scale segment, and the multi-scale segments are merged in the GPU through a stitching operation to construct a cross-scale interactive tensor.

[0102] S44. The neighborhood aggregation tensor, the structural reweighted feature tensor, and the cross-scale interaction tensor are fused at the channel level. The three-branch feature integration is achieved by using a parallel weighted mapping method, and the graph embedding tensor is output.

[0103] In this embodiment, S5 specifically includes:

[0104] S51. Expand the graph embedding tensor according to the time index of the sliding window, construct the time series tensor in the GPU global memory in a row-first manner, and ensure that the embedding vectors of adjacent windows are arranged continuously in memory. Call the custom data loader to divide the expanded embedding tensor into equal-length segments and load them into the input port of the recurrent neural network in time order.

[0105] S52. Establish a one-way causal constraint mechanism. Enable a one-way structure in the recurrent neural network, using gated recurrent units as the basic modeling units. Create independent thread blocks for each time step in the CUDA kernel function. Each thread reads the graph embedding vector at the current time step and extracts historical state variables from the hidden state tensor of the previous time step. It performs gated activation function calculations in shared memory, and after updating the hidden state at the current time step, writes the result to the hidden state buffer. Only forward propagation of historical states is allowed; no future time step information is read. Specifically, this includes:

[0106] During the GPU initialization phase, an independent thread block is allocated for each time step in the CUDA kernel function, and a hidden state buffer and a graph embedding vector buffer are preset in shared memory.

[0107] Each thread extracts the corresponding graph embedding vector from the current time index position and reads the hidden state tensor cached in the previous time step;

[0108] The gated activation kernel function is called to calculate and update the gate value, reset the gate value and candidate state in sequence, and generate the hidden state at the current time by combining dot product, addition and nonlinear activation function;

[0109] Write the calculation result to the hidden state buffer at the corresponding location and mark it as read-only;

[0110] The current thread is prohibited from accessing state data at future index positions to ensure that the state propagation process strictly satisfies a one-way causal relationship.

[0111] After each round of calculation, the state writing progress of all threads is coordinated through thread synchronization instructions, and finally the recursive modeling process on the entire time series is completed.

[0112] S53. After completing the recursive modeling for all time steps, the error between the final hidden state tensor and the target degradation label is calculated. The mean squared error is used to construct the loss tensor. On the GPU, the backpropagation graph structure is enabled, and the chained differentiation process is executed. The historical states in the hidden state buffer are traversed sequentially. The shared weighted inner product kernel function is called to accumulate gradients for the network parameters. The accumulated gradients are used to update the weight matrix through the gradient descent method, and the hidden state vector corresponding to each time index is output to form a set of degradation representations used to describe the evolution trend of fatigue damage.

[0113] In this embodiment, S6 specifically includes:

[0114] S61. Load the set of degenerate representations into shared memory in chronological order. Use the window sliding convolution algorithm to detect the local change trend of the degenerate values. Perform batch calculations on the average slope, mean square volatility and slope change density within the sliding window on the GPU. Divide the initial slow change stage, the middle stable stage and the final acceleration stage based on the set threshold range, and record the start and end indices of each stage.

[0115] S62. Based on the start and end indices of each stage, the degenerate representation set is segmented and sliced. Local dynamic regression modeling tensors corresponding to each stage are constructed. A neural network regression model is used to perform fitting training on the three start and end indices. During the training process, an optimizer with regularization terms is used to control the network convergence speed. Forward propagation and error backpropagation operations are performed in the GPU parallel thread to complete the nonlinear modeling of the degenerate curves of each stage.

[0116] The neural network regression model is a feedforward neural network consisting of an input layer, two hidden layers, and an output layer. The input layer receives the degradation representation vector of the corresponding stage, the hidden layer extracts nonlinear features through an activation function, and the output layer generates the fitted degradation trend value. The model structure is constructed on the GPU through tensor initialization, and the weight parameters are iteratively updated by the gradient descent method.

[0117] S63. The degradation curves generated by the neural network regression model are spliced ​​together in chronological order to form a complete multi-segment degradation curve. Based on the slope of the degradation curve output in the final acceleration stage, the rate of change of degradation value and the range of stable deviation, the interpolation inverse solution operation is performed in the GPU to derive the time step required from the current moment to the termination criterion. This step step is then multiplied by the sliding window width to obtain the remaining lifetime prediction value.

[0118] Example 1:

[0119] To verify the feasibility of this invention in practice, it was applied to the operation and maintenance of a high-speed rotating mechanical device. This device contains multiple key fastener components subjected to high-frequency vibration and cyclic loads. These fasteners are subjected to complex load conditions and alternating stress environments for extended periods, posing a high risk of fatigue damage. Traditional fatigue life assessment methods rely on manual inspection and periodic replacement strategies, lacking a dynamic assessment mechanism. This leads to premature failure of some fasteners, while others are still in good condition when replaced, resulting in high maintenance costs, poor reliability, significant resource waste, and safety hazards.

[0120] This invention deploys stress sensors, acceleration sensors, and load sensors near critical fasteners of equipment to collect axial stress, lateral vibration, and cyclic load signals in real time. Data preprocessing operations, including time alignment, noise reduction filtering, anomaly removal, and normalization, are performed on an embedded terminal. Under continuous operation, the system divides the collected monitoring data into fixed-length sliding windows, extracts multi-band energy distribution using wavelet packet decomposition, calculates signal complexity indices using spectral entropy and kurtosis, and constructs deformation rate features based on stress change rate, ultimately forming a multi-dimensional feature vector that integrates frequency domain, statistical, and waveform features.

[0121] By constructing a temporal correlation graph model, each time segment is treated as a node. Weighted edges are generated based on the stress change rate, vibration energy difference, and load amplitude difference between adjacent windows. The graph structure is constructed and stored in the GPU. Then, a diffusion kernel neighborhood aggregation and structural attention mechanism are used to extract graph features. A cross-scale feature mapping strategy is then combined to fuse multi-scale degradation patterns, generating a high-dimensional graph embedding tensor. This tensor is then input into a unidirectional recursive modeling network. During the modeling process, causal constraints are strictly followed, and the fatigue evolution trend of fasteners is learned step by step using only historical information.

[0122] In actual operation data, we selected continuous operation monitoring data for 48 sets of fasteners, covering operation times ranging from 120 to 960 hours and load frequencies ranging from 10Hz to 60Hz, forming over 250,000 sliding window feature vectors. Using the degradation trend sequence modeled and output by this invention, we further performed multi-segment nonlinear fitting, dividing it into initial gradual change, mid-term stable, and final accelerated stages. Based on the change in the curve slope in the final stage, we predicted the remaining lifespan. The system sets a lifespan warning threshold and performs comparative analysis on each set of fasteners.

[0123] Table 1 Comparison of Fatigue Life Prediction Effects of the Invention

[0124] F-001 812 795 2.1 36 F-002 645 670 3.9 28 F-003 921 899 2.4 31 F-004 744 718 3.5 22 F-005 587 595 1.4 34 F-006 670 703 4.9 19 F-007 889 872 1.9 27 F-008 610 589 3.4 23 F-009 763 752 1.4 25 F-010 801 777 3.0 30

[0125] The results show that, compared with traditional fatigue life estimation methods based on SN curves, this invention reduces the remaining life prediction deviation rate by an average of approximately 36.8%, and controls the prediction error of the actual failure time within ±5 hours. In terms of early warning accuracy, this method achieves an accuracy rate of 92.5%, with the early warning time concentrated between 20 and 40 hours before failure. Through reviewing historical misjudgments and omissions, the model of this invention exhibits stronger sensitivity to changes in fatigue state and can effectively identify periodic disturbances and nonlinear acceleration characteristics.

[0126] This invention also significantly reduces the analysis and calculation time. Under the GPU-accelerated computing framework, the average time to complete modeling and life prediction for a single set of fastener data is 0.86 seconds, which is more than 70% shorter than the traditional offline modeling process, and has strong online deployment capabilities.

[0127] Table 1 shows the performance evaluation data of the method of the present invention in actual fastener fatigue prediction tasks, covering indicators such as prediction deviation rate, actual life, predicted life, early warning time and model calculation time, which further verifies its technical feasibility and engineering applicability.

[0128] As can be seen from the data in Table 1, the method provided by this invention exhibits good life fitting ability and early warning accuracy under different fatigue loads and operating cycles. It effectively solves the problems of insufficient utilization of multi-source data, lagging model response, and inability to update in real time in traditional fatigue life estimation methods, and has clear engineering application value.

[0129] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A method for predicting the fatigue life of fasteners based on machine learning, characterized in that, Includes the following steps: S1. Collect monitoring data of fasteners during operation and perform preprocessing; S2. Divide the monitoring data into a sliding window of fixed length, and perform wavelet packet decomposition, spectral entropy analysis and deformation rate calculation to generate a feature vector set that integrates frequency domain features, statistical features and waveform features. S3. Construct a time-series correlation graph based on the feature vector set, using the feature vector corresponding to the sliding window as the graph node, and generating weighted edges based on the stress change rate, vibration energy difference, and load amplitude difference of adjacent nodes. S4. Based on the temporal correlation graph, perform neighborhood aggregation based on diffusion kernel, node reweighting based on structural attention, and feature interaction based on cross-scale mapping respectively, and merge the graph embedding tensors generated by each branch. S5. Expand the graph embedding tensor along the time index, perform recursive modeling and parameter backpropagation based on unidirectional causal constraints, and generate a set of degenerate representations that characterize the trend of damage evolution. S6. Perform multi-segment dynamic regression modeling on the degradation representation set, and fit the degradation curves of the initial slow-change stage, the middle stable stage and the final accelerated stage respectively. Calculate the remaining lifetime prediction value based on the curve change rate. S7. Align the remaining life prediction value with the time index, set threshold conditions and combine them with strategy optimization logic to judge the fatigue state, and output the life risk warning result of the fastener.

2. The fastener fatigue life prediction method based on machine learning according to claim 1, characterized in that, The monitoring data is collected synchronously by stress sensors, acceleration sensors, and load sensors installed near the fasteners. The monitoring data includes axial stress, lateral vibration, cyclic load, and temperature signals. The preprocessing includes time alignment, signal denoising, outlier removal, and numerical normalization of the monitoring data to output a standardized monitoring sequence. The strategy optimization logic refers to dynamically adjusting the warning level and maintenance response strategy based on the remaining life prediction results and preset thresholds to achieve risk minimization and optimal resource scheduling.

3. The fastener fatigue life prediction method based on machine learning according to claim 1, characterized in that, S2 specifically includes: S21. Divide the standardized monitoring sequence into sliding time windows of equal length according to the time axis, set the offset step size between each window, record the start and end index of each window during the sliding process, and form a monitoring segment sequence arranged in chronological order. S22. For each monitoring segment, the Daubechies wavelet basis function with symmetrical support structure is used to perform layer-by-layer wavelet packet decomposition on the GPU to extract the energy values ​​corresponding to all sub-bands. The energy ratio of each sub-band is recorded in the GPU shared memory as a frequency domain feature vector reflecting the frequency domain distribution characteristics of the signal. S23. For the axial stress signal and transverse vibration signal in each monitoring segment, perform spectral entropy analysis in the GPU, specifically including: The original signal data block is loaded into the local buffer, and a fast Fourier transform operation is performed to extract the spectrum data. After the spectrum amplitude is normalized, the frequency probability density distribution is calculated according to the frequency distribution. Based on the frequency probability density, the spectral entropy value is calculated in parallel on the GPU. The mean difference and variance of adjacent sample pairs are calculated on the original signal, a multidimensional embedding vector is constructed, and similarity statistics are performed on the vector sequence to output the sample entropy value. The original signal is normalized to zero mean, and the ratio between the peak value deviating from zero mean and the waveform stretching amplitude is calculated as the kurtosis index. Finally, the three results of spectral entropy, sample entropy and kurtosis are merged and stored in the statistical feature vector to characterize the frequency complexity and time domain variation characteristics of the signal in the current window. S24. Using the central difference method, perform batch difference processing on the stress sequence in each monitoring segment on the GPU, calculate the stress change rate at each time point, extract the maximum change rate, average change rate and standard deviation in sequence, combine the three results into a deformation rate feature vector, and use a memory-shared structure to stitch it into the monitoring segment. S25. The frequency domain features, statistical features and deformation rate features corresponding to each monitoring segment are structurally spliced ​​in the global memory of the GPU to generate a fusion vector after merging the three types of features, and uniformly numbered according to time order to form a feature vector set.

4. The fastener fatigue life prediction method based on machine learning according to claim 3, characterized in that, The extraction process of the frequency domain features specifically includes: For each monitoring segment within a sliding window, the normalized axial stress signal is loaded into the GPU's global memory. The CUDA kernel function is then called to perform a layer-by-layer wavelet packet decomposition operation on the signal. Each layer uses the Daubechies wavelet basis function to construct a filter bank. High-pass and low-pass filtering is performed on the signal in parallel using GPU threads. The filtering results are downsampled to generate the sub-band signal of the current layer. The energy of all sub-band signals is summed by squaring point by point to obtain the energy value of each frequency band. The sum of the energy values ​​of each frequency band is then calculated in the GPU register, and the energy value of each frequency band is normalized according to a preset ratio. The normalized energy distribution constitutes a frequency domain feature vector. The vector result is written to the local buffer through the GPU device memory, completing the extraction of the frequency domain features of the current window.

5. The fastener fatigue life prediction method based on machine learning according to claim 1, characterized in that, S3 specifically includes: S31. Arrange the feature vector set in chronological order, set each feature vector to correspond to a graph node, and connect adjacent feature vectors in sequence according to the sliding window order to form a set of node pairs, which serves as the initial skeleton of the time series graph structure. S32. For each pair of adjacent nodes, extract the stress change rate index from the corresponding feature vector, calculate the difference between the maximum stress value of the next node and the maximum stress value of the previous node, and write the difference into the stress channel of the edge feature matrix on the GPU. The stress channel is constructed by calculating the difference between the maximum stress values ​​in adjacent sliding windows. S33. Extract vibration energy index from the corresponding feature vector, calculate the sum of wavelet decomposition subband energy in the two nodes respectively, calculate the absolute value of their difference, and form the vibration energy difference of the edge feature matrix. Shared memory is used to avoid repeated memory access. The vibration energy difference is determined based on the difference of the sum of wavelet packet decomposition energy of adjacent nodes. S34. Extract the maximum amplitude of the cyclic load from the feature vector set, calculate the difference in load amplitude between adjacent nodes, assign the result to the load channel of the edge feature matrix, and use a multi-threaded structure to perform parallel calculations on all node pairs and write them into the edge feature matrix. S35. Perform uniform weighting processing on the edge feature matrix on the GPU, set a fixed weight coefficient template, use GPU vector multiplication to calculate the weight value of each edge, output the edge weight matrix, and combine the node set with the edge weight matrix to construct the completed temporal correlation graph.

6. The fastener fatigue life prediction method based on machine learning according to claim 1, characterized in that, S4 specifically includes: S41. Perform a neighborhood aggregation operation based on the diffusion kernel on the temporal correlation graph: Read the edge weight vector corresponding to each node, build a node adjacency table in shared memory, set the propagation step size and neighborhood range according to the diffusion kernel model, use sparse matrix multiplication to realize the transfer and fusion of node features between adjacent nodes, obtain the neighborhood aggregation tensor, and cache the neighborhood aggregation features of each node in the local buffer. S42. Perform a node reweighting process based on structural attention for each node in the temporal correlation graph: Load the feature vectors of each graph node and all its neighboring nodes into the GPU global memory, and concatenate the node's own features with the features of each neighboring node according to the channel dimension to generate a node pair feature sequence. The CUDA parallel kernel function is called to perform dot product operation on all node pairs, and the structural similarity weights are calculated in combination with the learnable query vectors. The weight vectors corresponding to each node are stored in shared memory. For each node, the feature vectors of all its neighboring nodes are summed according to their corresponding weights to form the reweighted feature representation of the current node. Finally, the reweighted feature vectors of all nodes are merged to generate the structural reweighted feature tensor. S43. Perform cross-scale mapping on the neighborhood aggregation tensor and the structure-reweighted feature tensor: A scale grouping scheme is set up to divide each feature tensor into multiple scale segments according to the channel dimension. Convolutional channel compression operation is used to unify the dimension of each scale segment, and the multi-scale segments are merged in the GPU through a stitching operation to construct a cross-scale interactive tensor. S44. The neighborhood aggregation tensor, the structural reweighted feature tensor, and the cross-scale interaction tensor are fused at the channel level. The three-branch feature integration is achieved by using a parallel weighted mapping method, and the graph embedding tensor is output.

7. The fastener fatigue life prediction method based on machine learning according to claim 1, characterized in that, S5 specifically includes: S51. Expand the graph embedding tensor according to the time index of the sliding window, construct the time series tensor in the GPU global memory in a row-first manner, and ensure that the embedding vectors of adjacent windows are arranged continuously in memory. Call the custom data loader to divide the expanded embedding tensor into equal-length segments and load them into the input port of the recurrent neural network in time order. S52. Set a one-way causal constraint mechanism, enable the one-way structure in the recurrent neural network, use the gated recurrent unit as the basic modeling unit, create an independent thread block for each time step in the CUDA kernel function, each thread reads the graph embedding vector at the current time step, extracts the historical state variables from the hidden state tensor of the previous time step, performs the gated activation function calculation in shared memory, and writes the result to the hidden state buffer after completing the hidden state update of the current time step. Only the historical state is allowed to be forward-propagated, and no information from future time steps is read. S53. After completing the recursive modeling for all time steps, the error between the final hidden state tensor and the target degradation label is calculated. The mean squared error is used to construct the loss tensor. On the GPU, the backpropagation graph structure is enabled, and the chained differentiation process is executed. The historical states in the hidden state buffer are traversed sequentially. The shared weighted inner product kernel function is called to accumulate gradients for the network parameters. The accumulated gradients are used to update the weight matrix through the gradient descent method, and the hidden state vector corresponding to each time index is output to form a set of degradation representations used to describe the evolution trend of fatigue damage.

8. The fastener fatigue life prediction method based on machine learning according to claim 1, characterized in that, S6 specifically includes: S61. Load the set of degenerate representations into shared memory in chronological order. Use the window sliding convolution algorithm to detect the local change trend of the degenerate values. Perform batch calculations on the average slope, mean square volatility and slope change density within the sliding window on the GPU. Divide the initial slow change stage, the middle stable stage and the final acceleration stage based on the set threshold range, and record the start and end indices of each stage. S62. Based on the start and end indices of each stage, the degenerate representation set is segmented and sliced. Local dynamic regression modeling tensors corresponding to each stage are constructed. A neural network regression model is used to perform fitting training on the three start and end indices. During the training process, an optimizer with regularization terms is used to control the network convergence speed. Forward propagation and error backpropagation operations are performed in the GPU parallel thread to complete the nonlinear modeling of the degenerate curves of each stage. The neural network regression model is a feedforward neural network consisting of an input layer, two hidden layers, and an output layer. The input layer receives the degradation representation vector of the corresponding stage, the hidden layer extracts nonlinear features through an activation function, and the output layer generates the fitted degradation trend value. The model structure is constructed on the GPU through tensor initialization, and the weight parameters are iteratively updated by the gradient descent method. S63. The degradation curves generated by the neural network regression model are spliced ​​together in chronological order to form a complete multi-segment degradation curve. Based on the slope of the degradation curve output in the final acceleration stage, the rate of change of degradation value and the range of stable deviation, the interpolation inverse solution operation is performed in the GPU to derive the time step required from the current moment to the termination criterion. This step step is then multiplied by the sliding window width to obtain the remaining lifetime prediction value.

Images