An aero-engine test data decision rule automatic generation method

Abstract

The application discloses an aero-engine test data decision rule automatic generation method, and relates to the field of intelligent aero-engine test, comprising: a semantic parser converts an optimized rule strategy set into executable code, calls a high-fidelity model for interactive verification through a digital twin mechanism, and generates a deployable rule package; the deployable rule package dynamically adjusts the weight and rule parameters of a knowledge graph, regularly starts an evolution cycle, generates an optimized rule package, re-performs rule generation processing on the optimized rule package, generates input data and transmits the input data to an updated state space, and restarts a rule generation process to form a closed-loop optimization cycle. Through the construction of a rule generation system integrating a knowledge graph and reinforcement learning, and the combination of digital twin verification and online learning mechanism, the aero-engine test decision rule is realized from static document writing to dynamic self-optimization, and the fault identification accuracy, rule self-adaptive ability and system maintenance efficiency are significantly improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of intelligent testing of an aero-engine, and in particular to a method for automatically generating decision rules for aero-engine test data. BACKGROUND

[0002] With the development of aero-engine test technology towards digitization and intelligence, the traditional decision rule management method based on static documents has been difficult to meet the real-time and reliability requirements of complex test scenarios. The existing technology mainly adopts two schemes: one is to rely on pre-defined experience to generate static rule documents, and to realize rule management through a fixed process; the other is to use a rule engine based on fixed thresholds to realize simple decision-making through pre-defined logic conditions. In recent years, knowledge graph technology and reinforcement learning methods have been preliminarily applied in the field of industrial decision-making, providing a new technical path for the structured processing of test data.

[0003] However, the existing technology has obvious limitations: first, the static rule generation method lacks adaptive optimization capability and cannot dynamically adjust rule parameters according to test data, resulting in insufficient coverage of new fault modes and boundary conditions; second, rule logic verification relies on a fixed process, making it difficult to realize version management and consistency maintenance of complex strategies, and is prone to rule conflicts and logic loopholes when dealing with multi-source heterogeneous test data. In particular, under extreme test conditions such as high temperature and high pressure of an aero-engine, the real-time decision-making accuracy and rule traceability of the existing methods need to be improved. SUMMARY

[0004] In view of the above existing problems, the present application is proposed.

[0005] Therefore, the present application provides a method for automatically generating decision rules for aero-engine test data, which solves the problems of insufficient adaptive ability and dynamic optimization lag of the static document experience rule generation method.

[0006] To solve the above technical problems, the present application provides the following technical solutions:

[0007] In a first aspect, the present application provides a method for automatically generating decision rules for aero-engine test data, which includes,

[0008] Collecting test data and integrating historical documents, constructing a knowledge graph through natural language processing, and generating a structured data file;

[0009] The structured data file maps entities and relationships in the knowledge graph to numerical vectors through a feature extractor in a deep reinforcement learning model, constructs a state space, and obtains an optimized rule strategy set through a rule action mechanism and a reward function evaluation mechanism;

[0010] The semantic parser converts the optimization rule strategy set into executable code, calls the high-fidelity model for interactive verification through the digital twin mechanism, and generates a deployable rule package;

[0011] The deployable rule package dynamically adjusts the weight and rule parameters of the knowledge graph, regularly starts an evolution cycle, generates an optimized rule package, reprocesses the optimized rule package for rule generation, generates input data and transmits it to an updated state space, and restarts the rule generation process to form a closed-loop optimization cycle.

[0012] As a preferred scheme of the aero-engine test data decision rule automatic generation method, wherein: the test data includes real-time sensor time series data, environmental parameter data, fault case data and process data.

[0013] As a preferred scheme of the aero-engine test data decision rule automatic generation method, wherein: the knowledge graph is constructed by natural language processing, including the following steps,

[0014] The historical documents are parsed by natural language processing, and entity and relationship pairs are extracted from the historical documents;

[0015] The entity and relationship pairs are processed for knowledge graph construction, and are standardized stored by adopting attribute graph structure to form entity nodes and relationship edges;

[0016] The entity nodes and relationship edges are dynamically maintained, the node attribute values and edge weight coefficients in the knowledge graph structure are updated, and the structured knowledge graph data is generated.

[0017] As a preferred scheme of the aero-engine test data decision rule automatic generation method, wherein: the entity nodes contain sensor identifiers, fault types and logical condition metadata;

[0018] The relationship edge contains weight and confidence index.

[0019] As a preferred scheme of the aero-engine test data decision rule automatic generation method, wherein: the entity nodes and relationship edges in the knowledge graph are mapped into numerical vectors to construct a state space, including the following steps,

[0020] The entity nodes and relationship edges in the knowledge graph are mapped into the environment space of the deep reinforcement learning model;

[0021] Based on the environment space, the entity relationship in the environment space is converted into a numerical vector to generate a state space.

[0022] As a preferred embodiment of the automatic generation method for decision rules of aero-engine test data described in this invention, the step of obtaining an optimized set of rule strategies through a rule action mechanism and a reward function evaluation mechanism includes the following steps.

[0023] The state space is input into the policy network, and the rule action sequence is generated through forward propagation in the policy network.

[0024] The rule action sequence is converted into executable rules, historical test data is evaluated and processed through a reward function, and reward signals are generated by simulating the rule hit rate, false alarm rate and fault coverage rate indicators.

[0025] The reward signal is fed back to the policy network for parameter optimization. Through multiple rounds of iterative training, the policy network converges, generating a set of optimized rules and policies.

[0026] The reward signal is fed back to the policy network for parameter optimization. Through multiple rounds of iterative training, the policy network converges, generating a set of optimized rules and policies.

[0027] As a preferred embodiment of the automatic generation method for decision rules of aero-engine test data described in this invention, the semantic parser converts the set of optimization rule strategies into executable code, including the following steps.

[0028] The parser optimizes the rule policy set and performs lexical analysis and syntax parsing to generate a rule syntax tree structure;

[0029] The rule syntax tree is input into the code generator, which converts the syntax tree nodes into executable code according to the mapping rules.

[0030] As a preferred embodiment of the automatic generation method for decision rules of aero-engine test data described in this invention, the step of interactively verifying the high-fidelity model through a digital twin mechanism includes the following steps.

[0031] Receive the executable code converted by the semantic parser, configure the simulation parameters of the digital twin environment, and load the high-fidelity model;

[0032] Multiple fault condition data are injected into the high-fidelity model through the fault mode injection interface, and executable code is run in the digital twin environment to monitor and record triggering events in real time and generate rule output results.

[0033] The rule output results are compared with the fault condition data in real time to generate a difference dataset.

[0034] The difference dataset is input into the confusion matrix statistical process, and a set of validation metrics is generated by calculating the ratio of rule coverage to false alarm rate.

[0035] When the verification index set fails to meet the performance acceptance standards for the safety and reliability of aero-engine testing, rule optimization suggestions are generated and fed back to the rule generation and processing stage, and retraining and optimization are performed. When the verification index set meets the performance acceptance standards, a deployable rule package is generated.

[0036] As a preferred embodiment of the automatic generation method for decision rules of aero-engine test data described in this invention, the step of dynamically adjusting the weights and rule parameters of the knowledge graph and periodically initiating an evolutionary cycle includes the following steps.

[0037] Deployable rule packages are processed through incremental learning algorithms to dynamically analyze the accuracy of rule triggering and the effectiveness of fault identification, and automatically adjust the rule parameters in the knowledge graph;

[0038] Based on the adjusted rule parameters, the evolutionary cycle processing mechanism is initiated, and the rule mining algorithm is used to merge redundant rules and remove inefficient rules to generate an optimized rule package.

[0039] As a preferred embodiment of the automatic generation method for decision rules of aero-engine test data described in this invention, the optimized rules include an executable rule file set, verification indicators, performance reports, and update records.

[0040] The beneficial effects of this invention are as follows: By constructing a rule generation system that combines knowledge graphs and reinforcement learning, this invention achieves three core benefits: First, by transforming unstructured documents into dynamic knowledge graphs using natural language processing technology, it solves the problem of fragmented source data for rule generation, making entity relationships quantifiable and traceable. Second, the knowledge graph, as the semantic foundation for rule generation, provides a structured state space for subsequent reinforcement learning. Third, the digital twin verification process and the online learning mechanism form a closed-loop system for rule optimization, verifying rule coverage and false alarm rate through confusion matrix statistical indicators to ensure that the generated rules meet the safety thresholds for aero-engine testing. Fourth, the online learning module continuously adjusts the knowledge graph weights by monitoring engine performance data in real time, enabling the rule system to continuously evolve. Attached Figure Description

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

[0042] Fig. 1 A flowchart for an automatic generation method of decision rules for aero-engine test data.

[0043] Fig. 2A detailed flowchart for the construction and dynamic maintenance of knowledge graphs.

[0044] Fig. 3 A flowchart for reinforcement learning rule generation and optimization.

[0045] Fig. 4 A flowchart for digital twin verification and rule package generation. Detailed Implementation

[0046] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0047] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0048] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0049] Reference Figs. 1-4 As one embodiment of the present invention, this embodiment provides a method for automatically generating decision rules for aero-engine test data, comprising the following steps:

[0050] S1. Collect test data and integrate historical documents, construct a knowledge graph through natural language processing, and generate structured data files.

[0051] S1.1. Collect test data and integrate historical documents. Perform syntactic analysis and semantic role labeling on the historical documents through natural language processing, and extract entity and relation pairs from the processed historical documents.

[0052] Test data is collected through multi-source sensor interfaces (specifically, real-time time-series data streams generated by vibration sensors, temperature sensors, and pressure sensors), and fault case data and experience documents from historical documents are integrated to form a comprehensive data resource.

[0053] Historical documents in the comprehensive data resources are cleaned and formatted using natural language processing methods to generate standardized text data; grammatical relationships between words in the standardized text data are identified using dependency parsing methods to generate syntactic analysis trees;

[0054] The attention mechanism is used to extract the syntactic and semantic features of predicate nodes to form feature vectors, identify the semantic associations between predicates and arguments in the syntactic parsing tree, label their semantic relationships, and generate semantic role labeling results. The entity recognition mechanism is used to locate entities such as fault types and sensor parameters labeled with semantic roles, and the relation classification method is used to determine the semantic relationships such as cause and condition trigger between entities, and generate a set of entity and relation pairs.

[0055] It should be noted that dependency parsing is a method that performs part-of-speech tagging and word segmentation on normalized text data, identifies the core predicates and their modifiers in the sentence, determines the subordinate relationships between words through dependency grammar rules (such as subject-predicate relations, verb-object relations, attributive-head relations, etc.), and generates a hierarchical parse tree.

[0056] S1.2. Extracted entities and relations are used to construct the input knowledge graph. The entity is mapped to a node and the relation is mapped to an edge using the attribute graph structure mapping method. The attribute graph structure is used for standardized storage to form entity nodes and relation edges.

[0057] The attribute graph structure mapping method is used to map the relationships between nodes and edges of entities and relations, generating a preliminary set of nodes and edges.

[0058] The initial set of nodes and edges is defined using an attribute graph mapping method. Sensor identifiers, fault types, and logical condition metadata are added to each node to form an attributed set of nodes. The attributed set of nodes is then used to define edge relationships using the same method. Based on the frequency of entity relationships in historical test data, the frequency of entities (such as sensor parameters and fault types) in historical documents is statistically analyzed and normalized to obtain weights and confidence indices in the range of 0-1 (higher weight indices indicate stronger associations, and higher confidence indices indicate higher reliability). Weights and confidence indices are then added to each edge to form a complete node and edge attribute structure.

[0059] The complete node and edge attribute structure is standardized for storage. Node attributes are stored in the node attribute table and edge attributes are stored in the edge relationship table to generate a standardized storage structure. The standardized storage structure establishes network connection relationships between nodes and edges through topological connections, forming entity nodes and relation edges with complete topological connections.

[0060] It should be noted that the attribute graph structure mapping method is implemented by adding sensor identifiers, fault types, and logical condition metadata to each node in the node attribute definition stage to form a set of nodes with attributes. By defining edge relationships, weights and confidence indices are added to each edge to construct a complete node and edge attribute structure. Node attributes are stored in a node attribute table and edge attributes are stored in an edge relationship table through standardized storage to generate a standardized storage structure. Network relationships between nodes and edges are established through topology connection processing to form entity nodes and relational edges with complete topology connections.

[0061] S1.3. Entity nodes and relation edges are dynamically maintained by updating node attribute values ​​and edge weight coefficients in the knowledge graph to generate structured data files.

[0062] The real-time data update interface collects the time-series data stream of entity nodes and relation edges in real time, and converts the time-series data stream into node attribute update instructions and edge weight adjustment parameters. The node attribute update instructions and edge weight adjustment parameters match the corresponding entity nodes in the knowledge graph according to the sensor data type, update the sensor reading attribute values ​​and timestamps of the entity nodes, and generate node state change data.

[0063] The system analyzes node state change data through dynamic analysis and processing. A sliding window statistical method is used to segment time-series data through fixed time windows, calculating statistical measures such as the mean and variance of entity indicators within the window to identify changes in the strength of associations between entities. Based on these changes, the weight coefficients and confidence indices of relation edges in the knowledge graph are adjusted to generate an updated knowledge graph structure. The updated knowledge graph structure then uses an incremental learning algorithm to quantify the frequency of rule triggering events by comparing the number of rule-triggered events within a fixed time interval to the window duration. Simultaneously, a confusion matrix calculation method is used to calculate accuracy (e.g., true positive rate) and false alarm rate by statistically analyzing the number of true positive, false positive, true negative, and false negative events, resulting in multi-dimensional performance analysis results. Based on these performance analysis results, the weight coefficients and confidence indices are optimized and calibrated to generate calibrated knowledge graph data.

[0064] The node attributes, edge weights, and topological relationships in the calibrated knowledge graph data are converted into a standardized data format using a structured encoder, generating a structured data file.

[0065] S2. The structured data file uses the feature extractor in the deep reinforcement learning model to map the entity and relation pairs in the knowledge graph into numerical vectors, constructs the state space, and obtains the optimized rule policy set through the rule action mechanism and reward function evaluation mechanism.

[0066] S2.1. The structured data file is input into the feature extractor in the deep reinforcement learning model. The feature extractor extracts features from the entity nodes and relation edges in the knowledge graph and generates embedded vector representations of entity and relation pairs.

[0067] The structured data file is input into the feature extractor in the deep reinforcement learning model. The feature extractor parses the knowledge graph structure in the structured data file, identifies the attribute information of entity nodes and relation edges, and generates the parsed knowledge graph structure.

[0068] The entity nodes in the knowledge graph structure are aggregated by graph neural network method, and vector encoding is completed by nonlinear transformation to generate embedded vector representations of entity nodes. The relation edges are vectorized by concatenating the embedded vector representation of the source node of the relation edge with the edge's own attributes (such as weight and confidence) and performing linear transformation and nonlinear activation to generate embedded vector representations of relation edges.

[0069] The embedded vector representations of entity nodes and relation edges are combined into a complete embedded vector representation of entity and relation pairs through vector concatenation operations.

[0070] It should be noted that the graph neural network method is implemented by parsing the knowledge graph structure through a feature extractor, identifying the attributes of entity nodes (such as sensor identifiers and fault types) and the attributes of relation edges (such as weights and confidence levels). The graph neural network iteratively updates the features of entity nodes and relation edges through multiple neural network layers: by aggregating the information of entity nodes and their adjacent nodes and edges, an embedded vector representation of the entity node is generated; the relation edge generates an embedded vector representation by concatenating the endpoint node features (embedded vectors of the source node and the target node) with the edge's own attributes (such as weights and confidence levels); the embedded vector representation forms a complete entity-relation pair embedded representation through the concatenation operation.

[0071] Define the feature dimensions of entity nodes and relation edges in the knowledge graph, use a graph neural network structure to capture topological relationships, and generate embedded vector representations; initialize the parameters of the deep reinforcement learning model, configure the optimizer and loss function, use the Adam optimizer to dynamically adjust the learning rate, and use a contrastive loss function to optimize the Euclidean distance of entity nodes in the vector space through gradient descent to calculate the similarity loss between entity vectors; integrate the graph neural network structure, the initialized model parameters, and the configured optimizer and loss function through the deep reinforcement learning model compilation stage to complete the construction of the deep reinforcement learning model.

[0072] The feature extractor performs linear transformations and non-linear activation operations on entity nodes and relation edges in the knowledge graph through the forward propagation computation process of the graph neural network, generating embedded vector representations of entity and relation pairs. The iterative training process calculates the partial derivatives of the loss function with respect to the model weights layer by layer through the backpropagation algorithm, generating gradient vectors. The gradient vectors are multiplied by the learning rate to obtain the parameter update amount. The parameter update amount is used to adjust the weight matrix and bias terms until the loss function reaches the maximum number of iterations (e.g., 1000 times to prevent infinite training loops). When the deep reinforcement learning model performs stably, the training of the deep reinforcement learning model is completed.

[0073] S2.2. Embedded vector representation is mapped to the environment space of the deep reinforcement learning model, and the entity relationships in the environment space are converted into numerical vector representations. The numerical vector representations are used to construct the state space through state concatenation. The state space is input to the forward propagation calculation process of the policy network, and the weight matrix and activation function in the policy network are weighted and calculated to generate a sequence of rule actions.

[0074] It should be noted that state concatenation is a process of standardizing the dimensions of numerical vectors from different entity relationships in the environment space to ensure that each vector has the same feature dimension. The standardized vectors are then concatenated into a high-dimensional state vector in a specific order through vector concatenation operations, and the dimensional differences are eliminated through normalization to form a standardized state space that can be processed by the reinforcement learning model.

[0075] The forward propagation computation process involves inputting the state space as an input vector into the input layer of the policy network, and then performing linear transformations (i.e., multiplication and addition operations between the input data and the weight matrix) and nonlinear activations through the hidden layers to generate a probability distribution of the regular action sequence at the output layer.

[0076] S2.3. The rule action sequence is lexically and syntactically analyzed by a semantic parser and converted into executable rule code. The executable rule code is evaluated by a reward function, accesses the test data integrated in the knowledge graph, performs simulation calculations, calculates the rule hit rate, false alarm rate, and fault coverage rate of the test data, and generates a reward signal. The reward signal is fed back to the policy network for network parameter optimization. Through multiple rounds of iterative training, the policy network converges to a stable state, generating an optimized rule policy set.

[0077] The semantic parser performs word segmentation and tokenization on the rule action sequence to generate a lexical token sequence; it then performs syntactic analysis on the lexical token sequence, forming an abstract syntax tree structure through rule matching and tree construction operations, and generating a syntactic parsing result. The syntactic parsing maps the nodes of the abstract syntax tree to executable rule code.

[0078] Executable rule code accesses test data integrated in the knowledge graph. The test data executes the executable rule code in the digital twin environment, recording rule triggering events and result data. The rule triggering events and result data are compared with the rule triggering events through a confusion matrix statistical method to classify true positive, false positive, true negative and false negative events. The rule hit rate is calculated based on the number of events to generate performance index data.

[0079] Based on the indicator weights, the rule hit rate, false alarm rate, and fault coverage values ​​in the performance indicator data are weighted and summed to generate a reward signal. The reward signal is fed back to the parameter optimization of the policy network. The error function is defined as the error value between the reward signal and the policy network using the gradient descent algorithm. The partial derivative of the error function with respect to the policy network is calculated using the chain rule to generate the error gradient. The weight parameter matrix in the policy network is updated along the reverse direction of the error gradient to generate the adjusted policy network.

[0080] The adjusted policy network is trained iteratively. During the training process, the loss function in the policy network is continuously optimized. The loss function is gradually reduced by iteratively updating the network parameters. When the rate of change of the loss function is lower than the preset convergence threshold 1e-5, the loss function converges. The converged policy network outputs a sequence of rule actions, generating an optimized set of rule policies.

[0081] It should be noted that the preset convergence threshold is set to 1e-5, and the network parameters converge on average within 150±20 iterations; if the preset convergence threshold is relaxed to 1e-4, the number of convergence iterations is reduced to 80, resulting in a decrease of about 3% in the capture rate of complex faults.

[0082] The rule hit rate formula is:

[0083] ;

[0084] The formula for false alarm rate is:

[0085] ;

[0086] Fault coverage is:

[0087] ;

[0088] Where Rec is the rule hit rate, TP is the number of true positives, FN is the number of false negatives, FP is the number of false positives, TN is the number of true negatives, FPR is the false alarm rate, and TPR is the fault coverage rate.

[0089] The formula for the error between the reward signal and the policy network is:

[0090] ;

[0091] Where L is the error value. The actual value of the reward signal, This is the predicted value of the policy network.

[0092] S3. The semantic parser converts the optimized rule strategy set into executable code, calls the high-fidelity model for interactive verification through the digital twin mechanism, and generates a deployable rule package.

[0093] S3.1. The semantic parser converts the set of optimization rules and strategies into executable code. The executable code is then transmitted to the digital twin mechanism. The digital twin mechanism configures the simulation parameters of the digital twin environment according to the requirements of the aero-engine test scenario. After configuration, it loads the high-fidelity model for accurate physical simulation.

[0094] After receiving the executable code, the digital twin mechanism determines the simulation accuracy and operating boundary conditions based on the performance indicators (speed control accuracy, temperature fluctuation range) required in the aero-engine test scenario, and generates simulation parameter configuration instructions. The simulation parameter configuration instructions are then input into the digital twin environment for parameter configuration, completing the parameter initialization of the digital twin environment.

[0095] Once the parameters are initialized, the digital twin environment calls the high-fidelity model. Through the parameter mapping interface, the physical parameters (such as material properties and boundary conditions) of the high-fidelity model are aligned in data format and numerically coupled with the simulation parameters (such as mesh generation accuracy and time step) of the digital twin environment, thus establishing a digital twin simulation environment with physical accuracy simulation capabilities.

[0096] It should be noted that the simulation accuracy is directly derived from the speed control accuracy and temperature fluctuation range. The speed control accuracy requires the speed fluctuation range in the simulation to be less than ±0.5% (according to the statistical results of speed stability in historical test data, the speed fluctuation of more than 99.7% of qualified test records is controlled within ±0.5%), and the temperature fluctuation range needs to simulate the error range of the real sensor.

[0097] The operating condition boundary conditions are based on the performance limits required in the test scenario. Normal or extreme operating conditions are simulated by setting upper and lower limits (such as temperature range -50°C to 150°C, pressure range 0-10MPa).

[0098] S3.3. The digital twin mechanism injects various fault condition data into the accurate high-fidelity model through the fault mode injection interface, and runs executable code in the digital twin environment to monitor and record trigger events in real time and generate rule output results.

[0099] The digital twin mechanism injects various fault condition data into the accurate high-fidelity model through the fault mode injection interface, generating a high-fidelity model state containing fault condition data.

[0100] The high-fidelity model state runs executable code in the digital twin environment, generating runtime data streams; the runtime data streams are monitored in real time, triggering events in the runtime data streams are identified and event information is recorded, and rule output results are generated.

[0101] S3.4. The rule output results are compared with the fault condition data in real time to generate a difference dataset; the difference dataset is input into the confusion matrix statistical process, which calculates the rule coverage and false alarm rate indicators to generate a set of verification indicators.

[0102] The event records in the rule output are compared one by one with the event records in the fault condition data to determine the matching status of each event (including true positive, false positive, true negative and false negative), and an event matching status list is generated; the number of true positive events, false positive events, true negative events and false negative events in the event matching status list are counted to generate a difference dataset;

[0103] Based on the number of true positive events, false positive events, true negative events, and false negative events in the differential dataset, the rule coverage index and the false positive rate index are calculated; the rule coverage index and the false positive rate index are combined into a complete set of validation indicators.

[0104] S3.5. The verification indicator set is compared with the performance acceptance standard by comparing the verification indicator set with the performance acceptance standard for the safety and reliability of aero-engine test run, and a deployable rule package is generated.

[0105] The rule optimization decision-making mechanism analyzes the compliance status of the indicators in the comparison results between the verification indicator set and the performance acceptance criteria (rule coverage is not less than 90% and false alarm rate is not higher than 5%). When the comparison result indicates that the verification indicator set has not met the performance acceptance criteria, the rule optimization suggestion generation mechanism is triggered to generate rule optimization suggestions containing specific parameter adjustment directions. The rule optimization suggestions are then transmitted to the rule generation processing stage for retraining and optimization. When the comparison result indicates that the verification indicator set has met the performance acceptance criteria, a deployable rule package is generated.

[0106] It should be noted that the trade-off curve between rule coverage and false positive rate exhibits a non-linear characteristic. 90% coverage is the Pareto optimal point. When the coverage increases above 90%, the marginal increase in false positive rate accelerates sharply (for example, an increase in coverage from 90% to 95% will cause the false positive rate to surge from 5% to 15%). When the coverage drops below 90%, the false positive rate climbs non-linearly (for example, with a rule coverage of 85%, the false positive rate will jump from 10% to 15%).

[0107] S4. Deployable rule packages can dynamically adjust the weights and rule parameters of the knowledge graph, periodically start the evolution cycle, generate optimized rule packages, reprocess the optimized rule packages to generate input data and transmit it to the updated state space, and restart the rule generation process to form a closed-loop optimization cycle.

[0108] S4.1. Deployable rule packages can call performance index time-series data in the digital twin environment for dynamic analysis and automatically adjust rule parameters in the knowledge graph based on the analysis results.

[0109] The deployable rule package accesses the performance index time series data stored in the digital twin environment through the incremental learning algorithm process. The performance index time series data is processed through the sliding time window process, which divides the time series data into continuous window sequences at fixed time intervals, calculates the average value, variance and other statistical characteristics of the performance index in each window, and generates a statistical feature sequence.

[0110] The statistical feature sequence compares the changes in statistical features of adjacent windows through trend analysis, analyzes the changing trends of performance indicators, identifies the changing patterns of rule triggering accuracy and fault identification effect based on the analyzed changing trends, and automatically adjusts the weight coefficients of entity nodes and the confidence index of relation edges in the knowledge graph according to the changing trends of performance indicators.

[0111] It should be noted that the performance metrics time-series data includes historical records of rule coverage, false alarm rate, and response latency.

[0112] S4.2. The adjusted rule parameters are processed by a rule mining algorithm to merge redundant rules and remove inefficient rules, generating an optimized rule package.

[0113] Analyze the rule logic structure and historical performance data in the rule parameters to identify redundant and inefficient rules, and generate lists of redundant and inefficient rule identifiers.

[0114] The redundant rule identification list is generated by calculating the logical similarity of the rules and comparing them pairwise to produce a similarity matrix. The similarity matrix then logically merges the rules with high similarity (based on the principle of optimal silhouette coefficient, when the similarity is 0.8, the silhouette coefficient of the rule cluster reaches the optimal balance) in the redundant rule identification list to generate a merged rule set. The inefficient rule identification list is further simplified by removing inefficient rules based on performance threshold conditions.

[0115] The merged rule set and the simplified rule set are integrated, and the two sets are deduplicated and logically processed to generate an optimized rule package.

[0116] S4.3. Extract the rule parameters and knowledge graph from the optimized rule package to generate input data; input the input data into the feature extractor in the deep reinforcement learning model, update the state space construction process of the feature extractor, and restart the rule generation process to form a closed-loop optimization cycle.

[0117] Data extraction is performed on the rule parameters and knowledge graph in the optimized rule package. The numerical values ​​of the rule parameters and the structural information of the knowledge graph are extracted to generate a rule parameter dataset and a knowledge graph dataset.

[0118] The rule parameter dataset and the knowledge graph dataset are aligned in format and matched in dimension to form standardized input data. The standardized input data is then fed into the feature extractor in the deep reinforcement learning model to perform feature extraction processing and update the internal state space representation of the feature extractor in the deep reinforcement learning model.

[0119] The updated state space representation is initialized, and the complete process sequence from state space construction to rule generation and policy output is restarted, forming a closed-loop optimization loop.

[0120] This embodiment also provides a computer device applicable to the automatic generation method of decision rules for aero-engine test data, including: a memory and a processor; the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to realize the automatic generation method of decision rules for aero-engine test data as proposed in the above embodiment.

[0121] The computer device can be a terminal, comprising a processor, memory, communication interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, carrier networks, NFC (Near Field Communication), or other technologies. The display screen can be an LCD screen or an e-ink screen. The input devices can be a touch layer covering the display screen, buttons, a trackball, or a touchpad on the computer device's casing, or an external keyboard, touchpad, or mouse.

[0122] This embodiment also provides a storage medium storing a computer program. When executed by a processor, the program implements the automatic generation method for decision rules of aero-engine test data as proposed in the above embodiment. The storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read Only Memory (EPROM), Programmable Red-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk.

[0123] In summary, this invention achieves three core benefits by constructing a rule generation system that combines knowledge graphs and reinforcement learning: Firstly, it transforms unstructured documents into dynamic knowledge graphs using natural language processing, solving the problem of fragmented source data for rule generation and enabling quantifiable and traceable entity relationships. Secondly, the knowledge graph, as the semantic foundation for rule generation, provides a structured state space for subsequent reinforcement learning.

[0124] The rule-based action mechanism based on deep reinforcement learning overcomes the limitations of traditional static rules. By mapping entity relationships in a knowledge graph to a numerical vector state space, the agent can dynamically evaluate the effectiveness of rules through a reward function, thereby achieving autonomous optimization of rule parameters.

[0125] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A method for automatically generating decision rules for aero-engine test data, characterized in that: include, Collect test data and integrate historical documents, construct a knowledge graph through natural language processing, and generate structured data files; Structured data files use feature extractors in deep reinforcement learning models to map entities and relation pairs in knowledge graphs into numerical vectors, construct a state space, and obtain an optimized set of rule policies through rule-based action mechanisms and reward function evaluation mechanisms. The semantic parser converts the optimized rule strategy set into executable code, calls the high-fidelity model for interactive verification through the digital twin mechanism, and generates a deployable rule package; The system can deploy rule packages to dynamically adjust the weights and rule parameters of the knowledge graph, periodically start an evolution cycle, generate optimized rule packages, reprocess the optimized rule packages to generate rules, generate input data and transmit it to the state space, and restart the rule generation process to form a closed-loop optimization cycle. The method of using a digital twin mechanism to call a high-fidelity model for interactive verification includes the following steps: Receive the executable code converted by the semantic parser, configure the simulation parameters of the digital twin environment, and load the high-fidelity model; Multiple fault condition data are injected into the high-fidelity model through the fault mode injection interface, and executable code is run in the digital twin environment to monitor and record triggering events in real time and generate rule output results. The rule output results are compared with the fault condition data in real time to generate a difference dataset. The difference dataset is input into the confusion matrix statistical process, and a set of validation metrics is generated by calculating the ratio of rule coverage to false positive rate. When the verification index set fails to meet the performance acceptance standards for the safety and reliability of aero-engine testing, rule optimization suggestions are generated and fed back to the rule generation and processing stage, and retraining and optimization are performed. When the verification index set meets the performance acceptance standards, a deployable rule package is generated.

2. The method for automatically generating decision rules for aero-engine test data as described in claim 1, characterized in that: The test data includes real-time sensor timing data, environmental parameter data, fault case data, and process data.

3. The method for automatically generating decision rules for aero-engine test data as described in claim 1, characterized in that: The knowledge graph is constructed using natural language processing. Includes the following steps, Historical documents are parsed using natural language processing, and entity-relation pairs are extracted from them. The entity and relation pairs are processed into a knowledge graph and stored in a standardized manner using an attribute graph structure, forming entity nodes and relation edges; The entity nodes and relation edges are dynamically maintained, and the node attribute values ​​and edge weight coefficients in the knowledge graph structure are updated to generate structured knowledge graph data.

4. The method for automatically generating decision rules for aero-engine test data as described in claim 3, characterized in that: The entity node contains sensor identifiers, fault types, and logical condition metadata; The relation edges include weights and confidence indices.

5. The method for automatically generating decision rules for aero-engine test data as described in claim 1, characterized in that: The process of mapping entity nodes and relation edges in a knowledge graph to numerical vectors and constructing a state space includes the following steps: Map the entity nodes and relation edges in the knowledge graph to the environment space of the deep reinforcement learning model; Based on the rules for defining the environment space, the entity relationships in the environment space are converted into numerical vectors to generate the state space.

6. The method for automatically generating decision rules for aero-engine test data as described in claim 1, characterized in that: The process of obtaining an optimized set of rule strategies through a rule-based action mechanism and a reward function evaluation mechanism includes the following steps: The state space is input into the policy network, and the rule action sequence is generated through forward propagation in the policy network. The rule action sequence is converted into executable rules, historical test data is evaluated and processed through a reward function, and reward signals are generated by simulating the rule hit rate, false alarm rate and fault coverage rate indicators. The reward signal is fed back to the policy network for parameter optimization. Through multiple rounds of iterative training, the policy network converges, generating an optimized set of rules and policies.

7. The method for automatically generating decision rules for aero-engine test data as described in claim 1, characterized in that: The semantic parser converts the set of optimization rules and strategies into executable code, including the following steps. The parser optimizes the rule policy set and performs lexical analysis and grammatical parsing to generate a rule syntax tree structure; The rule syntax tree is input into the code generator, which converts the syntax tree nodes into executable code according to the mapping rules.

8. The method for automatically generating decision rules for aero-engine test data as described in claim 1, characterized in that: The dynamic adjustment of the weights and rule parameters of the knowledge graph, and the periodic initiation of the evolution cycle, includes the following steps: Deployable rule packages are processed through incremental learning algorithms to dynamically analyze the accuracy of rule triggering and the effectiveness of fault identification, and automatically adjust the rule parameters in the knowledge graph; Based on the adjusted rule parameters, an evolutionary cycle processing mechanism is initiated, and a rule mining algorithm is used to merge redundant rules and remove inefficient rules to generate an optimized rule package.

9. The method for automatically generating decision rules for aero-engine test data as described in claim 8, characterized in that: The optimized rules include an executable rule file set, verification metrics, performance reports, and update logs.

Images