Intelligent inspection system and method based on historical data enhancement and xLSTM algorithm

Abstract

The invention discloses an intelligent inspection system and method based on historical data enhancement and an xLSTM algorithm, and belongs to the technical field of intelligent measurement and control. A synthetic fault sample is generated through a deep convolutional generative adversarial network (DCNAN) to solve the problem of incomplete historical data, and high accuracy and high efficiency of fault diagnosis of the measurement and control system are realized in combination with an extended long-short-term memory network (xLSTM) technology. The system comprises a data enhancement module, an xLSTM classification module and an intelligent inspection process, and significantly improves the processing capability of unbalanced data and the recognition precision of a complex fault mode in the inspection process. The method is high in practicability and scientific in design, the inspection accuracy is improved, the inspection efficiency can be improved, and the method is suitable for energy-saving optimization and efficient operation scenes of a complex measurement and control system.

Description

Technical Field

[0001] This invention relates to the field of intelligent monitoring technology for industrial equipment, specifically to an intelligent inspection system and method based on historical data augmentation and the xLSTM algorithm. The system constructs an enhanced training set by fusing multi-source historical data, uses an improved xLSTM model to predict equipment status, and optimizes resource allocation using a dynamic task scheduling engine, significantly improving inspection efficiency and fault warning accuracy, thus providing core support for intelligent operation and maintenance of industrial equipment. Background Technology

[0002] With the advancement of industrial intelligence, intelligent inspection systems have been widely applied to the condition monitoring of industrial equipment such as motors, pumps, and pressure vessels. Their core function is to identify and issue warnings of abnormal conditions by analyzing historical and real-time data of equipment operation, thereby ensuring production safety. However, a key challenge facing these systems is the incompleteness of historical data. While historical data on the normal operation of industrial equipment can be accumulated over a long period to form large-scale datasets (e.g., more than 15,000 records), fault data is extremely scarce due to its low probability of occurrence (e.g., the annual number of faults per machine is usually less than 5) and short collection time (emergency shutdown is required to avoid accidents during faults). This results in a severe imbalanced sample problem: "redundant normal samples and scarce fault samples."

[0003] Specifically, the ratio of normal to faulty samples in historical databases often reaches 60:1 or even higher. This imbalance causes traditional diagnostic models to overfit the temporal features of the majority class (normal state) during training, resulting in a significant decrease in their ability to identify the minority class (faulty state). This manifests as an F1 score of only around 0.7 for fault identification and a false negative rate of over 20%, seriously threatening the safe operation of equipment.

[0004] To address the imbalanced sample problem, existing technologies mainly focus on data augmentation and classification models, but both have significant limitations:

[0005] In terms of data augmentation, traditional methods struggle to generate high-quality fault samples: oversampling methods such as SMOTE generate samples through interpolation, which can easily lead to feature overlap and fail to reflect the temporal differences in equipment fault characteristics (such as vibration signal fluctuations before a fault occurs); when traditional generative adversarial networks (GANs) generate samples, due to the lack of targeted processing of temporal data, the generated equipment state signals (such as temperature and pressure time series) have low consistency with the feature distribution of real signals, and obvious differences can be seen through heatmap comparison, leading to model overfitting to the pseudo features of the generated samples.

[0006] In terms of classification models, existing models struggle to handle long-sequence inspection data of equipment: traditional time-series models such as Long Short-Term Memory (LSTM) networks are limited by scalar storage capacity and cannot capture long-term temporal features of equipment failures (such as small state shifts a few minutes before the failure occurs); although Transformer can handle long sequences, its computational complexity is high, making it difficult to meet the real-time inspection requirements (single-sample inference requires ≤0.02 seconds), and it is sensitive to sample size and has poor generalization ability under imbalanced data.

[0007] In addition, the lack of synergy between data augmentation and classification models is another core bottleneck: during data augmentation, the generation strategy was not adjusted according to the specific characteristics of different equipment fault types, resulting in inconsistent quality of generated samples for the same type of fault; during the training of classification models, the network structure (such as the number and ratio of memory units) was not optimized, making it unable to adapt to the temporal characteristics differences of different equipment (such as the different frequency characteristics of motor vibration signals and pressure vessel pressure signals).

[0008] In summary, intelligent inspection systems face the core challenge of incomplete historical data. Existing technologies, due to insufficient data augmentation quality and limited classification model capabilities for long sequences, struggle to meet practical application needs. Therefore, there is an urgent need for an innovative technology that integrates data augmentation and efficient classification. This technology could generate high-quality fault samples and optimize temporal feature learning to improve the accuracy and real-time performance of fault identification in imbalanced scenarios, providing more reliable technical support for the safe operation of industrial equipment. Summary of the Invention

[0009] The overall technical solution of this invention revolves around the collaborative optimization of the "data layer - model layer - application layer," covering four core stages: "data preprocessing - data augmentation - model training - real-time monitoring," forming an end-to-end intelligent inspection chain.

[0010] Data preprocessing stage

[0011] Multi-dimensional operational data (such as time-series signals of vibration acceleration, temperature, pressure, and flow rate) were extracted from historical databases of industrial equipment. A sliding time window technique was used to construct samples: the window length was set to 250 (corresponding to 5 seconds of data, with a sampling rate of 50Hz), and the step size was 5 (adjacent windows overlapped by 245 time steps). Continuous time-series data was converted into a 250×14 sample matrix (14 signals corresponding to 14 columns, and 250 time steps corresponding to 250 rows). This setup preserves the complete temporal characteristics at the time of the fault and enhances the continuity of the samples through overlapping windows, providing high-quality input for subsequent data augmentation and model training.

[0012] Data augmentation

[0013] To address the sample imbalance caused by the scarcity of fault samples in historical data (the ratio of normal samples to fault samples can reach 60:1), DCGAN is used to generate high-quality fault samples for augmentation. By training DCGAN separately for each type of fault sample, augmented samples with a feature distribution highly consistent with the real samples are generated, achieving a balanced ratio of normal samples to fault samples of 3:1 in the augmented dataset. This step solves the problems of low sample quality and feature overlap generated by traditional oversampling methods, providing sufficient and effective fault samples for model training.

[0014] Model training phase

[0015] The enhanced balanced dataset is input into the xLSTM network for training. By optimizing the network structure and parameters, the model can fully learn the temporal feature differences between normal and fault states of the equipment. The xLSTM adopts a stacked structure of "3 m-blocks + 1 s-block". The m-block is responsible for capturing long-term dependencies in long-sequence data (such as trend changes before equipment failure), while the s-block focuses on short-term feature details (such as instantaneous signal fluctuations when a failure occurs). The two work together to improve the comprehensiveness and accuracy of feature extraction.

[0016] Real-time monitoring

[0017] The trained xLSTM model is deployed to a real-time inspection terminal for industrial equipment to process and determine the status of collected real-time operating data (sampling rate 50Hz) in real time. Real-time samples are generated using a sliding window technique consistent with the data preprocessing stage. After being input into the model, the model outputs equipment status labels (normal / fault) and confidence levels. An alert is triggered when the fault confidence level is ≥0.95, ensuring timely response to equipment anomalies. The single-sample inference time is ≤0.02 seconds, meeting the real-time requirements of industrial scenarios.

[0018] II. Implementation of Key Technologies

[0019] DCGAN-based data augmentation module

[0020] The core of this module is to generate high-quality fault samples through adversarial training between the generator and the discriminator, thus addressing the problem of scarce fault samples in historical data. The technical details are as follows:

[0021] Network architecture design

[0022] DCGAN consists of a generator and a discriminator, both employing deep convolutional neural network structures to capture the spatial correlations of temporal features. The generator contains six deconvolutional layers and batch normalization layers: the input is a 100-dimensional random noise vector, which is mapped to a 256×7×4 feature matrix through a fully connected layer. Then, five deconvolutional operations (kernel sizes of 3×3, 6×2, 4×2, 4×2, and 1×4, with stride and padding strategies to achieve dimension matching) gradually expand the feature map size, ultimately generating 250×14 fault samples (with dimensions consistent with real samples). Each layer of the generator uses the ReLU activation function (the last layer uses tanh), and the batch normalization layers stabilize the training process and prevent gradient explosion.

[0023] The discriminator consists of four convolutional layers and fully connected layers. The input is either a real or generated sample. The convolutional layers (kernel sizes of 2×2, 3×3, etc., stride of 2×2) progressively reduce the feature map size, extracting high-order temporal features. Finally, the fully connected layers output probability values ​​of 0 to 1 (1 representing a real sample, 0 representing a generated sample). The discriminator uses the Leaky ReLU activation function (slope 0.2) to enhance non-linear expressive power. Batch normalization layers are added after each convolutional layer to improve generalization ability and ensure effective differentiation between real and generated samples.

[0024] adversarial training mechanism

[0025] DCGAN training follows a cyclical mechanism of "generation-discrimination-alternating optimization," achieving high-quality sample generation through a game between the generator and the discriminator. The generator aims to generate faulty samples that are as close to reality as possible, causing the discriminator to misclassify them as real samples. The discriminator aims to accurately distinguish between real and generated samples, driving the generator to improve sample quality. During training, the loss functions for the generator and discriminator are as follows:

[0026] Generator loss function:

[0027]

[0028] Discriminator loss function:

[0029]

[0030] The training parameters were set as follows: generator learning rate 0.0001, discriminator learning rate 0.00001 (ratio 1:10) to avoid the discriminator being too powerful and causing the generator to fail to learn; batch size 32, training epochs 500; after each epoch, the quality of the generated samples was verified by comparing with the heatmap to ensure that the feature distribution of the generated samples was consistent with that of the real samples by more than 90% (e.g., mean deviation ≤5%, variance deviation ≤8%).

[0031] Sample augmentation strategy

[0032] For each type of fault sample, DCGAN generates multiple augmented samples, which are then merged with the original fault samples (200 samples / class). When the total number of fault samples in each class reaches a certain level, a balanced ratio of 3:1 is achieved between the generated samples and the normal samples. The consistency of the distribution between the generated samples and the real samples is verified through t-SNE feature visualization, ensuring that the generated samples do not introduce spurious features and providing a reliable data foundation for model training.

[0033] xLSTM-based classification module

[0034] This module addresses the feature extraction needs of long-sequence inspection data from industrial equipment. By integrating the advantages of scalar LSTM (sLSTM) and matrix LSTM (mLSTM), it solves the storage limitations and insufficient parallelism of traditional LSTM in long-sequence processing. Technical details are as follows:

[0035] Network architecture design

[0036] xLSTM employs a stacking method of "3 m-blocks + 1 s-block": the m-block is based on matrix LSTM and is responsible for capturing the global dependencies of long sequence data; the s-block is based on scalar LSTM and focuses on optimizing local feature details. The two are fused through residual connections to form a "global-local" collaborative feature learning mechanism.

[0037] m-block employs a "pre-dimensionality-upgrading projection" strategy: after layer normalization, the input features are first upgraded to a higher-dimensional space via a projection matrix (dimensionality-upgrading factor of 2), and then processed in the matrix memory unit. The cell state update of the matrix memory unit follows the formula:

[0038]

[0039] Where f is the forget gate, i t For the input gate, v t k t These are the value matrix and the key matrix, respectively. Complex relationships between features are captured through matrix interactions, and the temporal dependencies of the hidden states are removed (h). t Only depends on the current input x t With cell state C t It supports parallel computing and improves the efficiency of long sequence processing.

[0040] The s-block employs a "post-dimensional upscaling projection" strategy: input features are normalized by layers and then branched into scalar memory units. After processing, they are projected to a higher-dimensional space through a gated MLP (dimensionality upscaling factor 1.3) and then fused with the residual input. The gating computation of the scalar memory units uses an exponential activation function.

[0041] ft =exp(W hf h t-1 +W xf x t +b f )

[0042] i t =exp(W hi h t-1 +W xi x t +b i )

[0043] To avoid the gradient vanishing problem of the traditional Sigmoid activation function, a stabilizer is introduced.

[0044] m t =max(log(f) t )+m t-1 ,log(i t )) and normalized state n t =f′ t ⊙ nt-1 +i′ t This solves the numerical overflow problem caused by exponential gating, making cell state updates more stable.

[0045] Parameter configuration and training strategy

[0046] The key parameters of xLSTM are set as follows: m-block hidden layer dimension 64, s-block hidden layer dimension 32; batch size 64, training epochs 150, learning rate 0.001 (Adam optimizer); an early stopping strategy is adopted (training stops if the validation set loss does not decrease for 10 consecutive epochs) to avoid model overfitting.

[0047] Feature learning mechanism

[0048] The xLSTM process for feature extraction from the input 250×14 time-series samples consists of three steps: First, layer normalization eliminates the dimensional differences between signals from different sensors; then, three m-blocks are used to gradually capture the long-term time-series features of the device status (such as stable vibration patterns during normal operation and trend shifts before a fault occurs); finally, one s-block is used to optimize short-term feature details (such as instantaneous signal changes during a fault); and finally, a fully connected layer and a Softmax activation function are used to output nine status labels (one normal and eight faulty), achieving accurate classification of the device status.

[0049] Data augmentation and xLSTM convergence applications

[0050] The fusion of data augmentation and xLSTM is the core solution to the problem of incomplete historical data. Through the collaborative optimization of "data and model", high-precision fault identification is achieved in imbalanced sample scenarios. The specific fusion mechanism is as follows:

[0051] Data layer collaboration

[0052] When generating samples, DCGAN adjusts the kernel size and stride of the generator's deconvolution layer to address the differences in fault characteristics across different devices (e.g., motor faults are mainly characterized by abrupt vibration signal changes, while pump faults are mainly characterized by pressure signal fluctuations). This ensures a targeted match between the generated samples and the device's fault characteristics. Simultaneously, heatmap comparison and t-SNE feature visualization are used to verify the consistency of the generated samples' distribution with real samples, preventing the model from learning spurious features from the generated samples.

[0053] Model layer collaboration

[0054] During xLSTM training, the number of m-blocks and s-blocks is adjusted according to the time span of the equipment inspection data: for long-cycle faults (such as faults caused by equipment aging, with a time span ≥ 10 seconds), the number of m-blocks is increased (e.g., 4 m-blocks) to enhance the long-term feature capture capability; for short-cycle faults (such as faults caused by instantaneous impacts, with a time span ≤ 2 seconds), the number of s-blocks is increased (e.g., 2 s-blocks) to optimize short-term feature learning. Through confusion matrix analysis, the adjusted xLSTM achieves a recall rate of over 99% for all types of faults, validating the adaptability of the model structure.

[0055] Application layer collaboration

[0056] In the real-time inspection system, the parameter size of xLSTM is reduced (from 2 million to 500,000) through model quantization compression (such as INT8 quantization). Combined with lightweight processing of DCGAN-generated samples (such as retaining key feature dimensions and removing redundant noise), the inference speed of the model on edge computing devices (such as NVIDIA Jetson Xavier) is improved by 40%, with a single sample processing time of ≤0.02 seconds, meeting the performance requirements of real-time monitoring of industrial equipment. Simultaneously, a dynamic update mechanism is established: new fault samples are collected periodically, and the parameters of DCGAN and xLSTM are fine-tuned to adapt to feature drift caused by equipment aging, ensuring that the model maintains high recognition accuracy over the long term. Attached Figure Description

[0057] Figure 1 The system architecture diagram illustrates the data augmentation and xLSTM classification process.

[0058] Figure 2Generator network structure diagram.

[0059] Figure 3 Discriminator network structure diagram.

[0060] Figure 4 A visual comparison chart of sample distribution shows the balancing effect of faulty samples before and after data augmentation.

[0061] Figure 5 : xLSTM block structure diagram, showing the integration method of sLSTM and mLSTM.

[0062] Figure 6 : GAN network structure diagram. Detailed Implementation

[0063] The following uses a small fixed-wing UAV for intelligent inspection as an example, and with reference to the accompanying drawings, to explain in detail the specific implementation process of the present invention, covering four core steps: "data acquisition and preprocessing → DCGAN data augmentation → xLSTM model training → real-time diagnostic deployment", to verify the effectiveness of the technical solution.

[0064] Step 1: Historical Data Acquisition and Preprocessing of UAVs

[0065] This step aims to extract valid data from the drone historical database, construct an initial sample set through standardization, and provide a foundation for subsequent data augmentation and model training.

[0066] Data collection range

[0067] Six months of flight data were collected for a certain type of fixed-wing UAV, covering two types of states:

[0068] Normal samples: 15,760, from sensor data during normal drone flight, including 14 signals such as roll angle, pitch angle, X / Y / Z axis angular velocity, airspeed, and altitude, with a sampling rate of 50Hz;

[0069] Fault samples: 8 types of typical faults (such as aileron jamming, motor failure, abnormal battery voltage, etc.), 200 records for each type, from fault flight records (such as ground station logs and sensor data transmission).

[0070] Data preprocessing operations

[0071] Timing sample construction: The sliding time window technique is used to cut continuous data. The window length is set to 250 (corresponding to 5 seconds of data, 50Hz×5=250 time steps), and the step size is 5 (adjacent windows overlap by 245 time steps). The 14 signals are converted into a 250×14 sample matrix (each row represents 1 time step, and each column represents 1 signal) to ensure that the complete timing features before and after the fault occur are included.

[0072] Data standardization: Z-score standardization (mean 0, variance 1) is performed on each sample matrix to eliminate the dimensional differences between different sensor signals (e.g., angular velocity is in ° / s, height is in m).

[0073] Initial dataset features

[0074] After preprocessing, an initial dataset of 30,990 samples was generated, including 15,760 normal samples and 200 samples from each of the eight categories of faulty samples. The ratio of normal to faulty samples was 60:1, showing a severe imbalance. t-SNE visualization revealed that faulty samples, due to their small number, were scattered within clusters of normal samples, resulting in blurred feature boundaries. Directly using these samples for model training would lead to severe missed detections.

[0075] Step 2: Generation of UAV Fault Samples Based on DCGAN

[0076] This step addresses the issue of scarce faulty samples in the initial dataset by using DCGAN to generate high-quality augmented samples and balance the data distribution. The specific steps are as follows:

[0077] DCGAN network parameter configuration

[0078] Based on the temporal characteristics of UAV fault samples (such as abrupt changes in attitude angle and fluctuations in angular velocity when a fault occurs), the network structure of the generator and discriminator is designed.

[0079] Generator structure (e.g.) Figure 2 As shown):

[0080] The input is a 100-dimensional random noise vector (following a normal distribution N(0,1)), which is processed through 6 layers of deconvolution to generate 250×14 fault samples. The parameters of each layer are as follows:

[0081] Layer 1: Fully connected layer, which maps the noise vector into a 256×7×4 feature matrix;

[0082] Layers 2-6: Deconvolutional layers, with kernel sizes of 3×3, 6×2, 4×2, 4×2, and 1×4 respectively. The stride is combined with a padding strategy (same padding) to achieve dimension matching, and the output size gradually increases from 7×4 to 250×14.

[0083] Activation function: ReLU is used for the first 5 layers, and tanh is used for the last layer (output range [-1, 1], consistent with the distribution of the standardized data); batch normalization layers are added to each layer to stabilize the training process.

[0084] Discriminator structure (e.g.) Figure 3 As shown):

[0085] The input is either a real fault sample or a generated sample (250×14), which is processed through 4 convolutional layers to output the probability of authenticity (0~1). The parameters of each layer are as follows:

[0086] Layers 1-3: Convolutional layers, kernel sizes 2×2, 3×3, 3×3, stride 2×2, progressively reducing the feature map size;

[0087] Layer 4: Fully connected layer, outputs single-channel probability values;

[0088] Activation function: Leaky ReLU (slope 0.2) is used to enhance non-linear expressive power; batch normalization layers are added after each convolutional layer to avoid overfitting.

[0089] DCGAN adversarial training process

[0090] DCGANs were trained separately for each of the eight types of drone fault samples (one generator was trained for each fault type), and the training process followed a "generation-discrimination-alternating optimization" mechanism:

[0091] Training parameter settings:

[0092] The generator learning rate is 0.0001, and the discriminator learning rate is 0.00001 (ratio 1:10) to ensure that the generator has enough learning space; the batch size is 32, and the number of training rounds is 500; the Adam optimizer is used with β1 = 0.5 to improve training stability.

[0093] Loss function calculation:

[0094] Generator loss function:

[0095] The goal is to minimize the loss so that the generated samples are classified as "real".

[0096] Discriminator loss function:

[0097] The goal is to maximize the loss to accurately distinguish between real and fake samples.

[0098] Sample quality verification:

[0099] Every 50 training rounds, 100 generated samples are randomly selected and compared with real samples:

[0100] Visual verification: By comparing heatmaps, the generated samples and real samples have a high degree of consistency in feature distribution patterns (e.g., the positions of sudden changes in angular velocity when the fault occurs coincide);

[0101] Quantitative verification: Calculate the cosine similarity (≥0.92) and mean square error (≤0.05) between the generated samples and the real samples to ensure the consistency of numerical distribution;

[0102] Downstream validation: After adding the generated samples to the training set, the model's accuracy in identifying this type of fault improved by ≥10%, proving the effectiveness of the generated samples.

[0103] Fault Sample Expansion Results

[0104] After training, DCGAN generates 3800 augmented samples for each fault class. These are then merged with the original 200 fault samples, resulting in a total of 4000 fault samples per class. At this point, the ratio of normal samples (15760) to fault samples (32000) is optimized to 3:1, forming a balanced dataset. t-SNE visualization (e.g.) Figure 4 As shown in the figure, the faulty samples form independent clusters with clear feature boundaries from the normal samples, providing high-quality data for model training.

[0105] Step 3: xLSTM Model Training and Validation

[0106] This step uses a balanced dataset to train an xLSTM model, learns the temporal feature differences between the normal and fault states of the drone, and ensures model performance through multi-dimensional validation.

[0107] xLSTM network architecture configuration

[0108] Based on the long-term time-series characteristics of UAV flight data (250 time steps), a stacked structure of "3 m-blocks + 1 s-block" is adopted (e.g., Figure 5 As shown in the image, the parameter settings are as follows:

[0109] m-block (matrix LSTM):

[0110] It is responsible for capturing long-term temporal features of UAV failures (such as attitude deviation trends before failure). The hidden layer has a dimension of 64 and adopts a "pre-dimensional projection" strategy: after the input is normalized by the layer, it is first increased to a higher dimension space by the projection matrix (dimensionality increase factor 2) and then enters the matrix memory unit.

[0111] s-block (scalar LSTM):

[0112] Focusing on the short-term, instantaneous features of UAV malfunctions (such as sudden changes in angular velocity at the time of malfunction), the hidden layer has a dimension of 32 and employs a "post-dimensionality-up projection" strategy: the input is normalized by the layer and then branched into scalar memory units; the output features are normalized by the group and then up-dimensionalized through a gated MLP (dimensionality-up factor 1.3), before being dimensionality-reduced and fused with the residual input. The gating uses exponential activation.

[0113] f t =exp(W hf h t-1 +W xf x t +bf )

[0114] i t =exp(W hi h t-1 +W xi x t +b i )

[0115] This avoids the gradient vanishing problem of the traditional Sigmoid function and enhances the ability to preserve scalar features.

[0116] Output layer:

[0117] A fully connected layer with a Softmax activation function outputs 9 categories of labels (0 = normal, 1-8 = corresponding fault types) to achieve multi-class classification.

[0118] Model training process

[0119] The balanced dataset was divided into a training set (24,792 samples) and a validation set (6,198 samples) in a 4:1 ratio. The training process is as follows:

[0120] Training parameters:

[0121] Batch size 64, learning rate 0.001 (Adam optimizer), 150 training epochs; an early stopping strategy is adopted, and training is stopped when the validation set loss does not decrease for 10 consecutive epochs to avoid overfitting.

[0122] Training curve monitoring:

[0123] In the early stages of training (1-50 rounds), the loss on both the training and validation sets decreased rapidly (from 1.2 to 0.15); in the middle stages (51-120 rounds), the loss slowly decreased to below 0.02 and then stabilized; finally, the loss on the validation set stabilized at 0.018 and the loss on the training set was 0.012, with a difference of ≤0.01, proving that the model was not overfitting.

[0124] Model performance verification

[0125] The classification ability of xLSTM was verified using multi-dimensional metrics, and the results are as follows:

[0126] Feature visualization: t-SNE visualization shows that normal samples (dots) and 8 types of fault samples (triangles of different shapes) form 9 independent clusters in the feature space. Samples of the same type are closely clustered, and the distance between samples of different types is ≥0.8 (Euclidean distance), proving that the model has strong feature extraction capabilities.

[0127] Classification metrics: The confusion matrix shows that the recognition accuracy of all types of faults is ≥99.5%, with the recall rate of key faults such as "aileron jamming" and "motor failure" reaching 100%; the overall F1 score improved from 0.7171 (unenhanced model) to 0.9988, verifying the effectiveness of data augmentation and model fusion.

[0128] Efficiency verification: On an NVIDIA GTX 1080Ti graphics card, xLSTM has an inference time of 0.018 seconds for a single sample, which meets the time requirement for real-time diagnosis of UAVs (≤0.02 seconds) and is better than traditional LSTM (0.032 seconds) and Transformer (0.056 seconds).

[0129] Step 4: Deployment and Application of Real-time UAV Diagnostics

[0130] This step involves deploying the trained model to the UAV ground station to enable real-time monitoring of flight data and fault early warning. The specific process is as follows:

[0131] Model Deployment Preparation

[0132] Model compression: xLSTM is compressed using INT8 quantization technology, reducing the parameter size from 2 million to 500,000, improving inference speed by 40%, and adapting to edge computing devices for UAV ground stations (such as NVIDIA Jetson Nano).

[0133] Interface Development: Develop a data receiving interface to communicate with the UAV flight control system via UDP protocol, receiving 14 channels of sensor data in real time (sampling rate 50Hz) with a latency of ≤50ms.

[0134] Real-time data processing flow

[0135] Data reception and buffering: The ground station receives sensor data every 50ms (25 time steps) and buffers the most recent 10 data to form a sliding window of 250 time steps (consistent with the training sample format).

[0136] Real-time standardization: Online standardization (based on historical mean and standard deviation) is applied to cached data to output a 250×14 real-time sample matrix.

[0137] Fault early warning mechanism

[0138] Diagnostic results output: The inference time of xLSTM for real-time samples is ≤0.02 seconds. It outputs the probability distribution of 9 states and takes the label corresponding to the maximum probability as the diagnostic result.

[0139] Multi-level warning: When the fault probability is ≥0.95, a level 1 warning is triggered (audio-visual alarm + fault type display); when the fault probability is 0.8≤fault probability<0.95, a level 2 warning is triggered (text prompt "suspected fault"); when the fault probability is <0.8, it is judged as normal.

[0140] Practical application effect

[0141] In 100 tests conducted at a certain UAV test flight field, the performance of this invention is as follows:

[0142] Missed detection rate: Only one "minor battery voltage fluctuation" fault was missed, with a missed detection rate of 1%, which is far lower than the 28% rate for systems not deployed.

[0143] False alarm rate: Two normal flights were mistakenly identified as "suspected malfunctions", with a false alarm rate of 2%, which can be ruled out after manual review;

[0144] Early warning timeliness: For serious faults such as "motor failure", the average early warning time is 2.3 seconds earlier than manual observation, which buys time for emergency response.

[0145] Through the above steps, the present invention fully realizes the entire process of "data augmentation-model training-real-time diagnosis", effectively solving the problem of low fault identification accuracy caused by incomplete historical data of UAVs, and providing reliable technical protection for UAV flight safety.

Claims

1. An intelligent inspection system and method based on historical data augmentation and xLSTM algorithm, characterized in that, The system includes a historical data storage module, a data augmentation module, a model training module, and a real-time diagnostic module; the historical data storage module is used to store historical data from multiple sources of sensors in the measurement and control system, including normal state data and sparse fault state data; The data augmentation module extracts fault samples from historical data and generates synthetic fault samples through a deep convolutional generative adversarial network (DCGAN) to balance the ratio of normal to fault samples. The model training module trains an extended long short-term memory network (xLSTM) based on the augmented dataset. The xLSTM is an integration of scalar LSTM (sLSTM) blocks and matrix LSTM (mLSTM) blocks. The real-time diagnosis module deploys the trained xLSTM model, performs fault classification on the real-time collected measurement and control data, outputs inspection results, and triggers automated operation and maintenance responses.

2. The intelligent inspection system and method according to claim 1, characterized in that, In the data augmentation module: the DCGAN generator contains 4 deconvolutional layers, with kernel sizes increasing from 3×3 to 7×7, strides configured from (1,1) to (2,2), and the number of output channels decreasing from 256 to 1. The DCGAN discriminator contains 4 convolutional layers, employing the Leaky ReLU activation function, with the last layer being a Sigmoid that outputs the probability of authenticity.

3. The intelligent inspection system and method according to claim 1, characterized in that, The xLSTM comprises: one sLSTM block, employing a post-upgrading projection strategy (projection factor 1.3), with a hidden layer dimension of 32 and an exponentially gated activation function; and three mLSTM blocks, employing a pre-upgrading projection strategy (projection factor 2), with a hidden layer dimension of 64, supporting parallel matrix computation.

4. The intelligent inspection system and method according to claim 3, characterized in that, The stabilizer calculation of the sLSTM block satisfies: stabilizer = max(f t i t Pre-sequence stabilizer) Where f t For the output of the forget gate, i t This is the input gate output, used to prevent exponentially gated values ​​from overflowing.

5. An intelligent inspection method based on historical data augmentation and xLSTM algorithm, characterized in that, Includes the following steps: Step 1: Extract fault samples from the historical database, train DCGAN to generate synthetic samples, and increase the proportion of fault samples to 1:3 of normal samples; Step 2: Construct an xLSTM network by stacking 3 mLSTM blocks and 1 sLSTM block through residual connections, and connecting the end to a fully connected classification layer; Step 3: Train xLSTM based on the augmented dataset, and minimize the cross-entropy loss using the Adam optimizer (learning rate 0.001); Step 4: Deploy xLSTM to the measurement and control system, input sensor timing data in real time, output fault type and probability, and drive automated inspection.

6. The intelligent inspection method according to claim 5, characterized in that, In step 1: the generated samples need to be verified by FID; if FID < 15, it is considered an effective enhancement. The fault samples cover at least one of the following modes: abnormal voltage, excessive temperature, and signal interruption.

7. The intelligent inspection method according to claim 5, characterized in that, In step 4, the real-time data sampling frequency is 50Hz, and the data is input into the model in a window of 250 time steps. The diagnostic results include fault confidence, and an alarm is automatically triggered when the confidence level is >95%.

Images