Engine test run image fault detection method, system, medium and equipment

Abstract

An engine test image fault detection method, system, medium and device, in the method, a fault simulation detection data set is formed based on image data set labeling, an encoder is constructed by using a structured state space model, a multi-scale image feature tensor is input into the encoder to obtain an output image feature embedding; a decoder of a target detection model is constructed by using the structured state space model and an efficient cross attention mechanism according to the image feature embedding and a query tensor, to obtain a new query tensor; the target detection model is obtained according to the encoder and the decoder, combined with a ResNet backbone network and a head network; image acquisition of liquid rocket engine test is carried out by using a high-speed camera, to obtain engine actual test fault image data; and the fault detection model after lightening is used to detect the engine actual test fault image data.

Description

Technical Field

[0001] This invention relates to the field of liquid rocket engine technology, and in particular to a method, system, medium, and equipment for detecting faults in engine test images. Background Technology

[0002] Liquid rocket engines are core components of launch vehicles, operating under extreme conditions such as high pressure, high temperature, high flow velocity, and strong vibration. Firing tests are crucial for verifying their performance indicators and operational reliability. During firing tests, high-speed camera systems are widely used to capture the engine's operating status in real time, including injection combustion stability, plume morphology evolution, structural thermal distribution characteristics, and deformation or abnormal states of key components. While this visual information is mostly non-quantitative data, it contains rich operational status and potential fault characteristics, possessing extremely high value for post-fire analysis and fault tracing. Therefore, fault detection technology based on intelligent image analysis is gradually becoming a core supporting means for achieving automated and intelligent diagnostics on liquid rocket engine firing platforms.

[0003] Currently, the processing of test image data still heavily relies on manual experience for interpretation, which presents several bottlenecks: First, a single test often generates a massive sequence of high-speed images with high data redundancy and low information density, making manual frame-by-frame screening inefficient and unable to meet the demands of rapid engineering response. Second, due to the high level of secrecy and professional threshold in the development of liquid rocket engines, image interpretation is usually undertaken by senior engineers, which is not only costly in terms of manpower but also susceptible to fluctuations in subjective experience, making it difficult to guarantee the consistency of interpretation results. Third, the actual test environment is complex and variable, with factors such as strong light reflection, high-temperature fog obstruction, high-speed motion blur, and sensor noise causing severe degradation in image quality. Traditional image processing methods and general target detection models are not robust enough in such high-interference, low-signal-to-noise-ratio scenarios, resulting in high false detection and false negative rates, which cannot support the stringent requirements of "high precision, high real-time performance, and high reliability" for fault diagnosis in high-end liquid rocket engines.

[0004] The information disclosed in the background section is only for enhancing the understanding of the background of this invention, and therefore may contain information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0005] This invention provides a method, system, medium, and equipment for fault detection in engine test images. By analyzing the non-quantitative visual information generated during engine testing, an accurate and efficient fault detection model is constructed, effectively solving the problem that the processing of fault image data after liquid rocket engine testing has long relied on manual labor. This technology has broad application prospects in the field of intelligent image fault diagnosis in the manufacturing and operation of high-end equipment.

[0006] A method for detecting faults in engine test images includes:

[0007] Step A: Use a high-speed camera to acquire images of the simulated fault from multiple shooting angles, at multiple resolutions, and at different sampling frame rates to form an image dataset;

[0008] Step B: Based on the annotation of the image dataset, a fault simulation detection dataset is formed. The ResNet backbone network is used to extract features from the images in the fault simulation detection dataset to obtain multi-scale image feature tensors.

[0009] Step C: Construct an encoder using a structured state-space model, inputting multi-scale image feature tensors into the encoder to obtain the output image feature embeddings. ;

[0010] Step D: Embedding based on image features and initializing the query tensor A decoder for the object detection model is constructed using a structured state-space model and an efficient cross-attention mechanism to obtain a new query tensor. ;

[0011] Step E: Based on the encoder and decoder, and combining the ResNet backbone network and head network, obtain the target detection model;

[0012] Step F: Train the target detection model using the fault detection dataset, and quantize the target detection model using the knowledge distillation method to obtain a lightweight fault detection model;

[0013] Step G: Acquire images of the liquid rocket engine test using a high-speed camera to obtain actual test failure image data of the engine;

[0014] Step H: Use the lightweight fault detection model to detect faults in the actual engine test image data.

[0015] In the aforementioned method for detecting engine test image faults, step B includes:

[0016] Step B1: Read in the i-th video data in the image dataset containing the fault image in chronological order, where 0 < i ≤ n, and n is an integer greater than or equal to 1;

[0017] Step B2: Sample video frames from a single video data set at a given sampling rate to obtain image data with fault characteristics;

[0018] Step B3: Manually filter and label the image data to obtain a dataset of faulty images;

[0019] Step B4: Perform steps B1 to B3 sequentially on all video data to obtain the fault simulation detection dataset.

[0020] In the aforementioned method for detecting engine test image faults, step C includes:

[0021] Step C1: Set the number of encoder layers in the encoder. Initialize position embedding Tensor embedding dimension Where B represents the batch size. H represents the dimension of the positional encoding, and H and W represent the height and width of the feature map in the multi-scale image feature tensor, respectively.

[0022] Step C2: Using position embedding For image feature tensors Position encoding embedding is performed to obtain a new image feature tensor. ;

[0023] Step C3: Convert the image feature tensor Input to Convolutional layers are used to reshape the tensors, resulting in feature embeddings. ,in ;

[0024] Step C4: Feature embedding New feature embeddings are obtained by performing standard state-space dual scan calculations. ;

[0025] Step C5: Feature embedding Perform layer normalization to obtain new feature embeddings. ;

[0026] Step C6: Embed the features The input is fed into a feedforward neural network layer to obtain a new feature embedding. ;

[0027] Step C7: Feature embedding Perform layer normalization to obtain the output of a single-layer decoder. ;

[0028] Step C8: Output of the single-layer encoder Repeat steps C4 to C7 as follows: Next, the image feature embedding output by the encoder is obtained. .

[0029] In the aforementioned method for detecting engine test image faults, step D includes:

[0030] Step D1: Set the number of decoder layers in the decoder Initialize the number of queries ,in quilt Divisible;

[0031] Step D2: For the query tensor Perform standard state-space dual scan computation to obtain a new query tensor. ;

[0032] Step D3: For the query tensor Perform layer normalization to obtain a new query tensor. ;

[0033] Step D4: Query tensor The input is fed into a fully connected layer and the tensor shape is reshaped to obtain the SSD algorithm embedding tensor. ;

[0034] Step D5: Broadcast the embedded tensor Expanding the sequence dimension yields a new SSD algorithm embedding tensor. ;

[0035] Step D6: Embed the image features into V and input it into the fully connected layer to obtain the SSD algorithm embedding tensor. , , , ;

[0036] Step D7: Embed the obtained SSD algorithm into a tensor , , , , The input is fed into the SSD algorithm module to obtain the query tensor output by the cross-attention module. ;

[0037] Step D8: For the query tensor Perform layer normalization to obtain a new query tensor. ;

[0038] Step D9: Query tensor The input is fed into the FFN layer to obtain a new query tensor. ;

[0039] Step D10: For the query tensor Perform layer normalization to obtain the output of a single-layer decoder. ;

[0040] Step D11: Output of the single-layer decoder Repeat steps D2~D10 Next, the query tensor output by the decoder is obtained. .

[0041] In the aforementioned method for detecting engine test image faults, step E includes:

[0042] Step E1: Use the ResNet backbone network to extract features from the input image to obtain the image feature tensor. ;

[0043] Step E2: Use the encoder to process the feature tensor Perform global feature interaction to obtain the output image feature embedding. ;

[0044] Step E3: Initialize the query tensor randomly. and image feature embedding The input is processed by the decoder to obtain a new query tensor. ;

[0045] Step E4: Use the head network to obtain the final detection results based on the new query tensor Q, and obtain the category, confidence and location of the faulty target in the image.

[0046] In the aforementioned method for detecting engine test image faults, step F includes:

[0047] Step F1: Set the network size of the teacher model to X and the network size of the student model to S in distillation learning;

[0048] Step F2: Use the fault simulation detection dataset for the training phase of the teacher model to obtain the fault detection model;

[0049] Step F3: Use the network weights of the teacher model to initialize the network parameters of the student model to obtain a lightweight fault detection model;

[0050] Step F4: Use the teacher model to guide the student model in feature alignment to obtain the fault detection model.

[0051] In the aforementioned method for detecting engine test image faults, step H includes:

[0052] Step H1: Preprocess the actual engine test failure image data, including denoising, illumination equalization, image alignment and resolution normalization, to obtain standardized image data that matches the model input requirements;

[0053] Step H2: Input the standardized image data into the fault detection model. The model performs forward inference on each frame of the image and outputs a visualized image containing fault annotations, fault location and size information, fault category identification results, and corresponding confidence scores.

[0054] Step H3: Combining time series analysis methods, perform time-series fusion and dynamic discrimination on the detection results of multiple consecutive frames to identify the persistence and evolution trend of anomalies, reduce false alarm rate, and improve the ability to detect intermittent or gradual faults.

[0055] Step H4: When the fault confidence in the detection results continuously exceeds the set threshold, or when significant fault characteristics are identified in a key area, a fault detection report containing timestamps, anomaly type, spatial location, and visualization images is generated.

[0056] A system for performing the method includes:

[0057] A high-speed image acquisition module is used to acquire multi-view video streams of the engine during the test run;

[0058] The preprocessing module is used to perform denoising, illumination equalization, image alignment, and resolution normalization.

[0059] Fault detection models are deployed on edge computing devices or servers;

[0060] The time-series analysis and report generation module is used to fuse multi-frame detection results and output a structured fault report.

[0061] A computer storage medium including computer instructions that, when run on a computer, cause the computer to perform the method.

[0062] An electronic device, the electronic device comprising:

[0063] Memory, processor, and computer programs stored in memory and executable on the processor, wherein,

[0064] The processor implements the method when executing the program.

[0065] Compared with existing technologies, this invention has the following advantages: Compared with traditional image fault analysis methods that rely on manual experience, this invention significantly improves the perception ability and anti-interference robustness of weak fault features in complex test images by constructing a lightweight neural network architecture that integrates structural state modeling and cross-modal feature interaction. The model strengthens the dynamic correlation between key regions and the global context through an efficient cross-attention mechanism, effectively suppressing environmental noise interference such as strong light, white fog, and motion blur, and significantly compressing inference latency while maintaining high detection accuracy. The lightweight model achieved by knowledge distillation effectively reduces the computational overhead of the operating equipment. This invention completely eliminates the reliance on manual frame-by-frame screening, improves fault identification efficiency by several orders of magnitude, significantly reduces labor costs and the risk of subjective misjudgment, and provides automated and intelligent technical support for rapid fault location and root cause analysis after engine testing, becoming an important upgrade and alternative to manual interpretation. This invention is not limited to the specific application scenario of fault detection in liquid rocket engine test images. Its core architecture has good generalization ability and can be applied to visual monitoring and intelligent diagnosis tasks of high-end equipment such as aero engines, gas turbines, and high-speed rotating machinery under extreme conditions. It is especially suitable for industrial visual inspection scenarios with strong image noise, variable target shape, and strict real-time requirements, and has broad engineering promotion value and industrialization prospects.

[0066] It should be noted that the present invention uses a lightweight fault detection model to detect faults in actual engine test image data. Although the lightweight fault detection model has relatively lower processing efficiency and higher latency, the application scenario targeted by the present invention is to replace manual processing and analysis of a large amount of image data left after engine test for fault detection rather than real-time monitoring. Attached Figure Description

[0067] Various other advantages and benefits of the present invention will become apparent to those skilled in the art upon reading the detailed description of the preferred embodiments below. The accompanying drawings are for illustrative purposes only and are not intended to limit the invention. It is obvious that the drawings described below are merely some embodiments of the invention, and those skilled in the art can obtain other drawings based on these drawings without any inventive effort. Furthermore, the same reference numerals denote the same parts throughout the drawings.

[0068] In the attached diagram:

[0069] Figure 1 This is a flowchart of an engine test image fault detection method based on a structured state-space model with a high efficiency of cross-attention mechanism, as described in this invention.

[0070] Figure 2The flowchart shows the encoder layer algorithm based on state space.

[0071] Figure 3 Here is a flowchart of the decoder layer algorithm based on an efficient cross-attention mechanism;

[0072] Figure 4 The flowchart shows the inference process of the query-based end-to-end detection model algorithm.

[0073] Figure 5 A schematic diagram of the lightweight fault detection model;

[0074] Figures 6 to 8 These are schematic diagrams showing the fault detection results of different embodiments of the present invention.

[0075] The present invention will be further explained below with reference to the accompanying drawings and embodiments. Detailed Implementation

[0076] The following will refer to the appendix. Figures 1 to 8 Specific embodiments of the invention will be described in more detail below. While specific embodiments of the invention are shown in the accompanying drawings, it should be understood that the invention may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided to enable a more thorough understanding of the invention and to fully convey the scope of the invention to those skilled in the art.

[0077] It should be noted that certain terms are used in the specification and claims to refer to specific components. Those skilled in the art will understand that different terms may be used to refer to the same component. This specification and claims do not distinguish components based on differences in terminology, but rather on differences in function. The terms "comprising" or "including" used throughout the specification and claims are open-ended and should be interpreted as "comprising but not limited to." The following descriptions are preferred embodiments for carrying out the invention; however, these descriptions are for the purpose of understanding the general principles of the specification and are not intended to limit the scope of the invention. The scope of protection of this invention is determined by the appended claims.

[0078] To facilitate understanding of the embodiments of the present invention, further explanations and descriptions will be provided below with reference to the accompanying drawings and specific embodiments. The accompanying drawings do not constitute a limitation on the embodiments of the present invention.

[0079] like Figures 1 to 4 As shown, the engine test image fault detection method includes the following steps:

[0080] Step A: Use a high-speed camera to acquire images of the simulated fault from multiple shooting angles, at multiple resolutions, and at different sampling frame rates to form an image dataset;

[0081] Step B: Based on the annotation of the image dataset, a fault simulation detection dataset is formed. The ResNet backbone network is used to extract features from the images in the fault simulation detection dataset to obtain multi-scale image feature tensors.

[0082] Step C: Construct an encoder using a structured state-space model, inputting multi-scale image feature tensors into the encoder to obtain the output image feature embeddings. ;

[0083] Step D: Embedding based on image features and initializing the query tensor A decoder for the object detection model is constructed using a structured state-space model and an efficient cross-attention mechanism to obtain a new query tensor. ;

[0084] Step E: Based on the encoder and decoder, and combining the ResNet backbone network and head network, obtain the target detection model;

[0085] Step F: Train the target detection model using the fault detection dataset, and quantize the target detection model using the knowledge distillation method to obtain a lightweight fault detection model;

[0086] Step G: Acquire images of the liquid rocket engine test using a high-speed camera to obtain actual test failure image data of the engine;

[0087] Step H: Use the lightweight fault detection model to detect faults in the actual engine test image data.

[0088] In a preferred embodiment of the engine test image fault detection method, step B includes:

[0089] Step B1: Read in the i-th video data in the image dataset containing the fault image in chronological order, where 0 < i ≤ n, and n is an integer greater than or equal to 1;

[0090] Step B2: Sample video frames from a single video data set at a given sampling rate to obtain image data with fault characteristics;

[0091] Step B3: Manually filter and label the image data to obtain a dataset of faulty images;

[0092] Step B4: Perform steps B1 to B3 sequentially on all video data to obtain the fault simulation detection dataset.

[0093] In a preferred embodiment of the engine test image fault detection method, step C includes:

[0094] Step C1: Set the number of encoder layers in the encoder. Initialize position embedding Tensor embedding dimension Where B represents the batch size. H represents the dimension of the positional encoding, and H and W represent the height and width of the feature map in the multi-scale image feature tensor, respectively.

[0095] Step C2: Using position embedding For image feature tensors Position encoding embedding is performed to obtain a new image feature tensor. ;

[0096] Step C3: Convert the image feature tensor Input to Convolutional layers are used to reshape the tensors, resulting in feature embeddings. ,in ;

[0097] Step C4: Feature embedding New feature embeddings are obtained by performing standard state-space dual scan calculations. ;

[0098] Step C5: Feature embedding Perform layer normalization to obtain new feature embeddings. ;

[0099] Step C6: Embed the features The input is fed into a feedforward neural network layer to obtain a new feature embedding. ;

[0100] Step C7: Feature embedding Perform layer normalization to obtain the output of a single-layer decoder. ;

[0101] Step C8: Output of the single-layer encoder Repeat steps C4 to C7 as follows: Next, the image feature embedding output by the encoder is obtained. .

[0102] In a preferred embodiment of the engine test image fault detection method, step D includes:

[0103] Step D1: Set the number of decoder layers in the decoder Initialize the number of queries ,in quilt Divisible;

[0104] Step D2: For the query tensor Perform standard state-space dual scan computation to obtain a new query tensor. ;

[0105] Step D3: For the query tensor Perform layer normalization to obtain a new query tensor. ;

[0106] Step D4: Query tensor The input is fed into a fully connected layer and the tensor shape is reshaped to obtain the SSD algorithm embedding tensor. ;

[0107] Step D5: Broadcast the embedded tensor Expanding the sequence dimension yields a new SSD algorithm embedding tensor. ;

[0108] Step D6: Embed the image features into V and input it into the fully connected layer to obtain the SSD algorithm embedding tensor. , , , ;

[0109] Step D7: Embed the obtained SSD algorithm into a tensor , , , , The input is fed into the SSD algorithm module to obtain the query tensor output by the cross-attention module. ;

[0110] Step D8: For the query tensor Perform layer normalization to obtain a new query tensor. ;

[0111] Step D9: Query tensor The input is fed into the FFN layer to obtain a new query tensor. ;

[0112] Step D10: For the query tensor Perform layer normalization to obtain the output of a single-layer decoder. ;

[0113] Step D11: Output of the single-layer decoder Repeat steps D2~D10 Next, the query tensor output by the decoder is obtained. .

[0114] In a preferred embodiment of the engine test image fault detection method, step E includes:

[0115] Step E1: Use the ResNet backbone network to extract features from the input image to obtain the image feature tensor. ;

[0116] Step E2: Use the encoder to process the feature tensor Perform global feature interaction to obtain the output image feature embedding. ;

[0117] Step E3: Initialize the query tensor randomly. and image feature embedding The input is processed by the decoder to obtain a new query tensor. ;

[0118] Step E4: Use the head network to obtain the final detection results based on the new query tensor Q, and obtain the category, confidence and location of the faulty target in the image.

[0119] In a preferred embodiment of the engine test image fault detection method, step F includes:

[0120] Step F1: Set the network size of the teacher model to X and the network size of the student model to S in distillation learning;

[0121] Step F2: Use the fault simulation detection dataset for the training phase of the teacher model to obtain the fault detection model;

[0122] Step F3: Use the network weights of the teacher model to initialize the network parameters of the student model to obtain a lightweight fault detection model;

[0123] Step F4: Use the teacher model to guide the student model in feature alignment to obtain the fault detection model.

[0124] In a preferred embodiment of the engine test image fault detection method, step H includes:

[0125] Step H1: Preprocess the actual engine test failure image data, including denoising, illumination equalization, image alignment and resolution normalization, to obtain standardized image data that matches the model input requirements;

[0126] Step H2: Input the standardized image data into the fault detection model. The model performs forward inference on each frame of the image and outputs a visualized image containing fault annotations, fault location and size information, fault category identification results, and corresponding confidence scores.

[0127] Step H3: Combining time series analysis methods, perform time-series fusion and dynamic discrimination on the detection results of multiple consecutive frames to identify the persistence and evolution trend of anomalies, reduce false alarm rate, and improve the ability to detect intermittent or gradual faults.

[0128] Step H4: When the fault confidence in the detection results continuously exceeds the set threshold, or when significant fault characteristics are identified in a key area, a fault detection report containing timestamps, anomaly type, spatial location, and visualization images is generated.

[0129] A system for performing the method includes:

[0130] A high-speed image acquisition module is used to acquire multi-view video streams of the engine during the test run;

[0131] The preprocessing module is used to perform denoising, illumination equalization, image alignment, and resolution normalization.

[0132] Fault detection models are deployed on edge computing devices or servers;

[0133] The time-series analysis and report generation module is used to fuse multi-frame detection results and output a structured fault report.

[0134] A computer storage medium including computer instructions that, when run on a computer, cause the computer to perform the method.

[0135] An electronic device, the electronic device comprising:

[0136] Memory, processor, and computer programs stored in memory and executable on the processor, wherein,

[0137] The processor implements the method when executing the program.

[0138] In one embodiment, such as Figure 1 The diagram shows the overall flow of an efficient cross-attention mechanism structured state-space model for engine test image fault detection. The following example, using liquid rocket engine post-test image fault detection, details the implementation steps as follows:

[0139] Step A: The visible faults that may occur in the liquid rocket engine during the test are simulated using a liquid rocket engine test fault simulation test bench. High-speed cameras are used to capture images of the simulated faults from multiple shooting angles, resolutions, and sampling frame rates, and these images are saved as general video or image formats containing various non-quantitative typical faults. Non-quantitative typical faults specifically refer to abnormal engine ignition, fuel and oxidizer leakage, and detachment of key sensors. These are visible to the naked eye but cannot be detected by data. Therefore, image monitoring is used as a supplement to engine anomaly monitoring.

[0140] Step B: Process the image data containing fault categories into the image detection dataset format used by the method of this invention;

[0141] For example, the specific process of step B is as follows:

[0142] Step B1: Read in the i-th (0 < i ≤ n) video data in the data set containing the fault image in chronological order;

[0143] Step B2: Sample video frames from a single video data set at a given sampling rate to obtain image data with significant fault characteristics;

[0144] Step B3: Manually screen and label the obtained image data to obtain a high-quality fault image dataset;

[0145] Step B4: Perform steps B1 to B3 sequentially on all video data to obtain the fault simulation detection dataset;

[0146] Step C: Output the image feature tensor for the backbone network of the query-based object detection model. The encoder of the object detection model is constructed using Structured State Space Models (SSMs), and the image feature embedding of the encoder is obtained. ;

[0147] For example, the specific process of step C is as follows:

[0148] Step C1: Set the number of encoder layers in the encoder. Initialize position embedding Tensor embedding dimension ;

[0149] Step C2: Using position embedding For image feature tensors Position encoding embedding is performed to obtain a new image feature tensor. ;

[0150] Step C3: Convert the tensor Input to Convolutional layers are used to reshape the tensors, resulting in feature embeddings. ,in ;

[0151] Step C4: Feature embedding New feature embeddings are obtained by performing a standard state-space duality (SSD) scan. ;

[0152] Step C5: Feature embedding Perform layer normalization (LN) to obtain new feature embeddings. ;

[0153] Step C6: Embed the features The input is fed into a feed-forward neural network (FFN) layer to obtain a new feature embedding. ;

[0154] Step C7: Feature embedding Perform layer normalization (LN) to obtain the output of a single-layer decoder. ;

[0155] Step C8: Output of the single-layer encoder Repeat steps C4 to C7. Next, the image feature embedding of the encoder is obtained. ;

[0156] Step D: Embed the image features from the encoder in step C. And the query tensor randomly initialized by the detection model A decoder for the object detection model is constructed using a structured state-space model and an efficient cross-attention mechanism to obtain a new query tensor. ;

[0157] For example, the specific process of step D is as follows:

[0158] Step D1: Set the number of decoder layers in the decoder Initialize the number of queries ,in quilt Divisible;

[0159] Step D2: For the query tensor Perform an SSD scan to obtain a new query tensor. ;

[0160] Step D3: For the query tensor Perform layer normalization (LN) to obtain a new query tensor. ;

[0161] Step D4: Query tensor The input is fed into a fully connected layer and the tensor shape is reshaped to obtain the SSD algorithm embedding tensor. ;

[0162] Step D5: Broadcast the embedded tensor Expanding the sequence dimension yields a new SSD algorithm embedding tensor. ;

[0163] Step D6: Embed the image features into V and input it into the fully connected layer for segmentation to obtain the SSD algorithm embedding tensor. , , ,initialization ;

[0164] Step D7: Embed the obtained SSD algorithm into a tensor , , , , The input is fed into the SSD algorithm module to obtain the query tensor output by the efficient cross-attention module. ;

[0165] Step D8: For the query tensor Perform layer normalization (LN) to obtain a new query tensor. ;

[0166] Step D9: Query tensor The input is fed into the FFN layer to obtain a new query tensor. ;

[0167] Step D10: For the query tensor Perform layer normalization (LN) to obtain the output of a single-layer decoder. ;

[0168] Step D11: Output of the single-layer decoder Repeat steps D2 to D10 as follows: Next, the query tensor output by the decoder is obtained. ;

[0169] I can understand, embedding tensors It works in conjunction with B, dt, and X from the image feature embedding V to form the input of SSD, and its technical role is to realize the feature interaction of the query tensor image feature embedding V.

[0170] See further Figure 3 The specific process of step D, as shown, reveals that this invention utilizes a structured state-space model and an efficient cross-attention mechanism to construct an SSD-based decoder; wherein,

[0171] The query tensor Q1 is obtained through SSD scanning and LN, and is transformed into cross-SSD through tensor reshaping and expansion. In this process, SSD scanning replaces the self-attention mechanism in the decoder in the prior art, and cross-SSD replaces the cross-attention mechanism in the decoder in the prior art.

[0172] It should be noted that this allows two sequences of different lengths to achieve "cross-learning," i.e., feature fusion, using SSD;

[0173] Therefore, it can be understood that, compared to the cross-attention mechanism in the prior art, the advantages of the above embodiments of the present invention are that they can significantly reduce computational complexity and significantly improve the efficiency of the decoder. It should be particularly emphasized that, in this field, improving efficiency or accuracy are both significant innovations. Since the above embodiments can significantly reduce computational complexity and significantly improve the efficiency of the decoder, these embodiments precisely illustrate one of the core innovative points of the present invention.

[0174] Further, step E: Based on the encoder and decoder of the object detection model constructed in steps C and D, combine the ResNet backbone network and head network to obtain the query-based object detection model;

[0175] The head network, or detection head, consists of two parallel fully connected networks (FFNs), used to predict the class and bounding box coordinates, respectively; among them,

[0176] The classification header consists of a single linear transformation, such as Linear(256 → num_classes+1);

[0177] The bounding box regression head consists of multiple linear transformations and ReLU functions, for example:

[0178] Linear(256 → 256) + ReLU

[0179] Linear(256 → 256) + ReLU

[0180] Linear(256 → 4);

[0181] For example, the specific process of step E is as follows:

[0182] Step E1: Use the ResNet backbone network to extract features from the input image to obtain the image feature tensor. ;

[0183] Step E2: Use the encoder to process the feature tensor Perform global feature interaction to obtain the output image feature embedding. ;

[0184] Step E3: Initialize the query tensor randomly. and image feature embedding The input is processed by the decoder to obtain a new query tensor. ;

[0185] Step E4: Use the head network to convert the query tensor Q into the final detection result, and obtain the category, confidence and location of the faulty target in the image;

[0186] Step F: Based on Step B and Step E, obtain the dataset and detection model, train the model using the fault detection dataset, and quantize the detection model using the knowledge distillation method to obtain a lightweight fault detection model;

[0187] The model adopts an end-to-end training approach, using learnable queries and Hungarian matching mechanisms to jointly optimize classification (usually Focal Loss) and bounding box (GIoU+L1) losses, and relies on pre-trained backbone networks (such as HGNetv2) to extract multi-scale features.

[0188] To ensure convergence, training employs strategies such as learning rate warmup, cosine decay, gradient clipping, auxiliary loss (supervised by each layer's decoder), reasonable loss weight balancing, and strong data augmentation (e.g., Mosaic / MixUp, which can be turned off initially). Simultaneously, hyperparameters are adjusted promptly by monitoring matching success rate and validation metrics. If convergence fails, the learning rate can be reduced, label quality checked, pre-trained weights enabled, or the model debugged from a smaller model, thus ensuring stable convergence to the expected performance.

[0189] The specific structure of the model is as follows Figure 5 As shown, the specific process of step F is as follows:

[0190] Step F1: Set the network size of the teacher model to X and the network size of the student model to S in distillation learning;

[0191] Step F2: Use the fault simulation detection dataset for the training phase of the teacher model to obtain a fault detection model with strong generalization ability and high detection accuracy;

[0192] Step F3: Use the network weights of the teacher model to initialize the network parameters of the student model, and obtain a lightweight fault detection model with the initial ability to identify typical fault features;

[0193] Step F4: Use the teacher model to guide the student model in feature alignment to obtain a lightweight and efficient fault detection model;

[0194] Further, step G: acquire images of the liquid rocket engine test using a high-speed camera to obtain actual test failure image data of the engine;

[0195] Step H: Based on the detection model and image data obtained in Steps F and G, use the fault detection model to perform fault detection on the test data; the specific process of Step H is as follows:

[0196] Step H1: Preprocess the actual engine test failure image data, including denoising, illumination equalization, image alignment and resolution normalization, to obtain standardized image data that matches the model input requirements;

[0197] Step H2: Input the standardized image data into the fault detection, perform forward inference on each frame of the image through the model, and output a visualized image containing fault annotations, fault location and size information, fault category identification results and corresponding confidence scores;

[0198] Step H3: Combining time series analysis methods, perform time-series fusion and dynamic discrimination on the detection results of multiple consecutive frames to identify the persistence and evolution trend of anomalies, reduce false alarm rate, and improve the ability to detect intermittent or gradual faults.

[0199] Step H4: When the fault confidence in the detection results continuously exceeds the set threshold, or when significant fault characteristics are identified in a key area, a fault detection report containing timestamps, anomaly type, spatial location, and visualization images is generated.

[0200] Therefore, it is evident that during the testing of liquid rocket engines, malfunctions may occur on the engine surface, such as abnormal fires, oxidizer and fuel leaks, or sensor detachment in critical components. Given the current situation where manual processing of post-test image data is time-consuming and labor-intensive, this invention utilizes a target detection algorithm to analyze image data from the test process. This algorithm efficiently and accurately identifies fault information (the location and fault type of abnormal objects such as abnormal flames, leaks, and sensor detachment) in each image, replacing manual intervention, and obtains relevant fault information for subsequent analysis and processing.

[0201] In another embodiment, see Figures 6 to 8 ,in,

[0202] Figure 6 This illustration shows the fault detection results of an embodiment of the present invention, which not only identified faults such as Figure 6 The fault location is shown, and the category is identified as: abnormal flame (i.e., fire), with a confidence level of 0.69;

[0203] Figure 7 This illustrates the fault detection result of another embodiment of the present invention, which not only identifies faults such as Figure 7 The two fault locations are shown, and the category is identified as leakage. The confidence levels of the two faults from left to right are 0.52 and 0.80, respectively.

[0204] Figure 8 This illustrates the fault detection result of another embodiment of the present invention, which not only identifies faults such as Figure 8 The two fault locations are shown, and the categories are identified as: component detachment (i.e., fall) and abnormal flame (i.e., fire), with confidence levels of 0.98 and 0.62 for the two faults from top to bottom, respectively.

[0205] This invention addresses the common problems in test images from fields such as rocket engines, including strong light reflection, high-temperature fog obscuring, high-speed motion blur, and low signal-to-noise ratio. Traditional object detection models based on convolution or Transformers often struggle to effectively model long-range contextual dependencies and suffer from high computational complexity and inference latency. This invention innovatively employs SSD to construct the encoder, performing global modeling of the two-dimensional image feature sequence with linear time complexity (O(N)) through a one-dimensional scanning operation, avoiding the O(N²) explicit attention matrix calculation required in self-attention mechanisms. This significantly reduces the model's demand on GPU memory and computing power, and enables the network to efficiently capture long-range semantic relationships between the injector region and the plume wake, thereby improving the ability to perceive weak, diffuse faults (such as early ablation and minor deformation).

[0206] Furthermore, in the decoding stage, this invention designs a highly efficient cross-attention module that integrates the SSD mechanism: the learnable query vector and the image features output by the encoder are embedded into a common input SSD computation unit. The dynamic interaction between query-key pairs is implicitly modeled through state-space equations, eliminating the need for explicit generation of high-dimensional attention weight maps. This mechanism significantly reduces the computational overhead of the decoder while maintaining cross-modal feature alignment capabilities. More importantly, the query mechanism naturally supports end-to-end object detection paradigms (such as DETR), directly outputting the category and bounding box of faulty targets, avoiding redundant computation and missed detection risks associated with candidate box generation in traditional two-stage detectors.

[0207] Furthermore, to meet the requirements of low power consumption, small size, and real-time performance for engineering deployment, this invention introduces a knowledge distillation strategy: first, a high-capacity teacher model is trained to fully learn complex fault modes, and then a lightweight student model is guided to inherit its discriminative ability through feature alignment and output imitation. This process not only compresses the number of model parameters and FLOPs, but also retains the sensitivity to minor anomalies in key areas (such as the combustion chamber outlet), solving the problem of underfitting in small models under conditions of scarce data and noise interference.

[0208] Finally, considering that single-frame images are susceptible to instantaneous interference leading to false alarms, this invention adds a temporal fusion analysis module in the inference stage: spatial-temporal correlation is performed on the detection results of multiple consecutive frames, and occasional noise is filtered through confidence smoothing, trajectory consistency verification and persistence criteria (such as "three consecutive frames detecting the same type of fault in the same area"), which significantly improves the detection reliability of progressive faults (such as material thermal fatigue crack propagation) or intermittent anomalies (such as periodic combustion oscillation).

[0209] Although embodiments of the present invention have been described above in conjunction with the accompanying drawings, the present invention is not limited to the specific embodiments and application fields described above. The specific embodiments described above are merely illustrative and instructive, and not restrictive. Those skilled in the art can make many other forms based on the guidance of this specification and without departing from the scope of protection of the claims of the present invention, and all of these are within the scope of protection of the present invention.

Claims

1. A method for detecting faults in engine test images, characterized in that, Includes the following steps: Step A: Use a high-speed camera to acquire images of the simulated fault from multiple shooting angles, at multiple resolutions, and at different sampling frame rates to form an image dataset; Step B: Based on the annotation of the image dataset, a fault simulation detection dataset is formed. The ResNet backbone network is used to extract features from the images in the fault simulation detection dataset to obtain multi-scale image feature tensors. Step C: Construct an encoder using a structured state-space model, inputting multi-scale image feature tensors into the encoder to obtain the output image feature embeddings. ; Step D: Embedding based on image features and initializing the query tensor A decoder for the object detection model is constructed using a structured state-space model and an efficient cross-attention mechanism to obtain a new query tensor. ; Step E: Based on the encoder and decoder, and combining the ResNet backbone network and head network, obtain the target detection model; Step F: Train the target detection model using the fault detection dataset, and quantize the target detection model using the knowledge distillation method to obtain a lightweight fault detection model; Step G: Acquire images of the liquid rocket engine test using a high-speed camera to obtain actual test failure image data of the engine; Step H: Use the lightweight fault detection model to detect faults in the actual engine test image data.

2. The method for detecting engine test image faults according to claim 1, characterized in that, Preferably, step B includes: Step B1: Read in the i-th video data in the image dataset containing the fault image in chronological order, where 0 < i ≤ n, and n is an integer greater than or equal to 1; Step B2: Sample video frames from a single video data set at a given sampling rate to obtain image data with fault characteristics; Step B3: Manually filter and label the image data to obtain a dataset of faulty images; Step B4: Perform steps B1 to B3 sequentially on all video data to obtain the fault simulation detection dataset.

3. The method for detecting engine test image faults according to claim 2, characterized in that, Step C includes: Step C1: Set the number of encoder layers in the encoder. Initialize position embedding Tensor embedding dimension Where B represents the batch size. H represents the dimension of the positional encoding, and H and W represent the height and width of the feature map in the multi-scale image feature tensor, respectively. Step C2: Using position embedding For image feature tensors Position encoding embedding is performed to obtain a new image feature tensor. ; Step C3: Convert the image feature tensor Input to Convolutional layers are used to reshape the tensors, resulting in feature embeddings. ,in ; Step C4: Feature embedding New feature embeddings are obtained by performing standard state-space dual scan calculations. ; Step C5: Feature embedding Perform layer normalization to obtain new feature embeddings. ; Step C6: Embed the features The input is fed into a feedforward neural network layer to obtain a new feature embedding. ; Step C7: Feature embedding Perform layer normalization to obtain the output of a single-layer decoder. ; Step C8: Output of the single-layer encoder Repeat steps C4 to C7 as follows: Next, the image feature embedding output by the encoder is obtained. .

4. The method for detecting engine test image faults according to claim 3, characterized in that, Step D includes: Step D1: Set the number of decoder layers in the decoder Initialize the number of queries ,in quilt Divisible; Step D2: For the query tensor Perform standard state-space dual scan computation to obtain a new query tensor. ; Step D3: For the query tensor Perform layer normalization to obtain a new query tensor. ; Step D4: Query tensor The input is fed into a fully connected layer and the tensor shape is reshaped to obtain the SSD algorithm embedding tensor. ; Step D5: Broadcast the embedded tensor Expanding the sequence dimension yields a new SSD algorithm embedding tensor. ; Step D6: Embed the image features into V and input it into the fully connected layer to obtain the SSD algorithm embedding tensor. , , , ; Step D7: Embed the obtained SSD algorithm into a tensor , , , , The input is fed into the SSD algorithm module to obtain the query tensor output by the cross-attention module. ; Step D8: For the query tensor Perform layer normalization to obtain a new query tensor. ; Step D9: Query tensor The input is fed into the FFN layer to obtain a new query tensor. ; Step D10: For the query tensor Perform layer normalization to obtain the output of a single-layer decoder. ; Step D11: Output of the single-layer decoder Repeat steps D2~D10 Next, the query tensor output by the decoder is obtained. .

5. The method for detecting engine test image faults according to claim 1, characterized in that, Step E includes: Step E1: Use the ResNet backbone network to extract features from the input image to obtain the image feature tensor. ; Step E2: Use the encoder to process the feature tensor Perform global feature interaction to obtain the output image feature embedding. ; Step E3: Initialize the query tensor randomly. and image feature embedding The input is processed by the decoder to obtain a new query tensor. ; Step E4: Use the head network to obtain the final detection results based on the new query tensor Q, and obtain the category, confidence and location of the faulty target in the image.

6. The method for detecting engine test image faults according to claim 1, characterized in that, Step F includes: Step F1: Set the network size of the teacher model to X and the network size of the student model to S in distillation learning; Step F2: Use the fault simulation detection dataset for the training phase of the teacher model to obtain the fault detection model; Step F3: Use the network weights of the teacher model to initialize the network parameters of the student model to obtain a lightweight fault detection model; Step F4: Use the teacher model to guide the student model in feature alignment to obtain the fault detection model.

7. The method for detecting engine test image faults according to claim 1, characterized in that, Step H includes: Step H1: Preprocess the actual engine test failure image data, including denoising, illumination equalization, image alignment and resolution normalization, to obtain standardized image data that matches the model input requirements; Step H2: Input the standardized image data into the fault detection model. The model performs forward inference on each frame of the image and outputs a visualized image containing fault annotations, fault location and size information, fault category identification results, and corresponding confidence scores. Step H3: Combining time series analysis methods, perform time-series fusion and dynamic discrimination on the detection results of multiple consecutive frames to identify the persistence and evolution trend of anomalies, reduce false alarm rate, and improve the ability to detect intermittent or gradual faults. Step H4: When the fault confidence in the detection results continuously exceeds the set threshold, or when significant fault characteristics are identified in a key area, a fault detection report containing timestamps, anomaly type, spatial location, and visualization images is generated.

8. A system for performing the method as described in any one of claims 1-7, characterized in that, It includes: A high-speed image acquisition module is used to acquire multi-view video streams of the engine during the test run; The preprocessing module is used to perform denoising, illumination equalization, image alignment, and resolution normalization. Fault detection models are deployed on edge computing devices or servers; The time-series analysis and report generation module is used to fuse multi-frame detection results and output a structured fault report.

9. A computer storage medium, characterized in that, The storage medium includes computer instructions that, when executed on a computer, cause the computer to perform the method as described in any one of claims 1-7.

10. An electronic device, characterized in that, The electronic device includes: Memory, processor, and computer programs stored in memory and executable on the processor, wherein, When the processor executes the program, it implements the method as described in any one of claims 1-7.

Images