A chiller fault data generation method, device, equipment, medium and product

Abstract

This application discloses a method, apparatus, equipment, medium, and product for generating chiller fault data, relating to the field of chiller faults. The method includes acquiring noise data and corresponding category labels for the chiller; using a trained fault data generation module to generate synthetic fault data from the noise data and the corresponding category labels; using the synthetic fault data to train a fault diagnosis module for fault diagnosis; the self-adversarial encoder of the fault data generation module extracts a local feature subspace through its local modeling branch and a global feature subspace through its global modeling branch; and fusing and linearly mapping the local and global feature subspaces to obtain latent variables. This application can improve the stability and quality of fault sample generation.

Description

Technical Field

[0001] This application relates to the field of chiller malfunctions, and in particular to a method, apparatus, equipment, medium, and product for generating chiller malfunction data. Background Technology

[0002] HVAC systems, an indispensable part of daily life, account for over 40% of global building energy consumption annually. Chillers, as the most complex subsystem, can further increase energy consumption if they malfunction after prolonged operation. Studies show that refrigerant leaks in chillers can reduce the cooling capacity of HVAC systems by 20%. Therefore, building an efficient and reliable fault detection and diagnosis (FDD) system for chillers is crucial for reducing energy waste and improving the operational reliability of HVAC systems. Machine learning-based methods can efficiently and accurately identify faults by mining historical operating data from equipment. However, data-driven methods still face many challenges in practical applications, the core issue being the reliance on large-scale, high-quality labeled data. In actual HVAC systems, operating data often exhibits a high proportion of normal samples and a scarcity of fault samples, leading to a severe imbalance in the training dataset and limiting the performance of data-driven methods. Furthermore, methods addressing the scarcity of fault samples suffer from poor quality and instability in fault sample generation. Summary of the Invention

[0003] The purpose of this application is to provide a method, apparatus, equipment, medium, and product for generating fault data of a chiller, which can improve the stability and quality of fault sample generation.

[0004] To achieve the above objectives, this application provides the following solution:

[0005] Firstly, this application provides a method for generating chiller fault data, including:

[0006] Obtain noise data and the corresponding category labels for the chiller;

[0007] The noise data and the category labels corresponding to the chiller are used to generate synthetic fault data using a trained fault data generation module; the synthetic fault data is used to train a fault diagnosis module for fault diagnosis; the trained fault data generation module includes a self-adversarial encoder, a discriminator, and a decoder.

[0008] The training process of the fault data generation module specifically includes:

[0009] Obtain the actual fault data and the category labels corresponding to the actual fault data;

[0010] The input sequence of the self-adversarial encoder is determined based on the actual fault data and the category labels corresponding to the actual fault data;

[0011] Based on the input sequence, a local feature subspace is extracted using the local modeling branch of the self-adversarial encoder;

[0012] The global feature subspace is extracted based on the input sequence using the global modeling branch of the self-adversarial encoder;

[0013] The local feature subspace and the global feature subspace are fused and linearly mapped to obtain latent variables;

[0014] The latent variables and prior distributions are input into the discriminator and decoder of the fault data generation module, respectively. The fault data generation module is trained based on the overall loss function obtained from the prior distribution and gradient penalty term, with the synthetic data as the output. The synthetic data is simulated synthetic fault data.

[0015] In one embodiment, the local modeling branch is a one-dimensional convolutional structure.

[0016] In one embodiment, the global modeling branch is a Mamba structure.

[0017] In one embodiment, extracting a global feature subspace based on the input sequence using the global modeling branch of a self-adversarial encoder specifically includes:

[0018] The input sequence is represented in a continuous state space.

[0019] Discretize the input sequence represented in continuous state space to obtain the discretized input sequence;

[0020] The state-space model is expanded based on the discretized input sequence to obtain the global feature subspace.

[0021] In one embodiment, the expression for the overall loss function is:

[0022] ;

[0023] in, Let be the objective function. For the discriminator output value, For the expected value, For the discriminator itself, for and The expected value of the difference between them. For the original The distribution of reconstructed values ​​generated by the values This is the original fault data without tag information. The reconstructed data output by the decoder. For hyperparameters, For the Euclidean norm, The output probability of the discriminator for the current data. As latent variables, As a prior distribution, This is the gradient penalty term.

[0024] In one embodiment, the chiller fault data generation method further includes:

[0025] The synthesized fault data is input into a classifier to obtain fault diagnosis results.

[0026] Secondly, this application provides a chiller fault data generation device, comprising:

[0027] The acquisition module is used to acquire noise data and the category labels corresponding to the chiller.

[0028] A generation module is used to generate synthetic fault data from the noise data and the category label corresponding to the chiller using a trained fault data generation module; the synthetic fault data is used to train a fault diagnosis module for fault diagnosis; the trained fault data generation module includes a self-adversarial encoder, a discriminator, and a decoder.

[0029] The training process of the fault data generation module specifically includes:

[0030] Obtain the actual fault data and the category labels corresponding to the actual fault data;

[0031] The input sequence of the self-adversarial encoder is determined based on the actual fault data and the category labels corresponding to the actual fault data;

[0032] Based on the input sequence, a local feature subspace is extracted using the local modeling branch of the self-adversarial encoder;

[0033] The global feature subspace is extracted based on the input sequence using the global modeling branch of the self-adversarial encoder;

[0034] The local feature subspace and the global feature subspace are fused and linearly mapped to obtain latent variables;

[0035] The latent variables and prior distributions are input into the discriminator and decoder of the fault data generation module, respectively. The fault data generation module is trained based on the overall loss function obtained from the prior distribution and gradient penalty term, with the synthetic data as the output. The synthetic data is simulated synthetic fault data.

[0036] Thirdly, this application provides a computer device, including: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the chiller fault data generation method.

[0037] Fourthly, this application provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the chiller fault data generation method described above.

[0038] Fifthly, this application provides a computer program product, including a computer program that, when executed by a processor, implements the chiller fault data generation method.

[0039] According to the specific embodiments provided in this application, the following technical effects are disclosed:

[0040] This application provides a method, apparatus, equipment, medium, and product for generating fault data for a chiller. The fault data generation module generates synthetic fault data. In the fault data generation module, the local modeling branch of the self-adversarial encoder extracts local feature subspaces and captures local features, and the global modeling branch extracts global feature subspaces and captures global features. This enables the fault data generation module to obtain more stable latent representations with small samples. At the same time, the fault data generation module can generate high-quality fault samples without additional sample screening. Attached Figure Description

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

[0042] Figure 1 This is a diagram of the overall structure.

[0043] Figure 2 This is a comparison chart of FDD methods based on AAE and FDD methods based on GAN or VAE.

[0044] Figure 3 Here is a diagram of the CMamba-AAE architecture;

[0045] Figure 4 A plot of FDD accuracy with or without filtering mechanisms at Level-1;

[0046] Figure 5 A plot of FDD accuracy with or without filtering mechanisms in Level-2;

[0047] Figure 6 The classification results in SVM at different levels are shown in the figure.

[0048] Figure 7 Flowchart of chiller fault data generation method;

[0049] Figure 8 A schematic diagram of the functional modules of the chiller fault data generation device;

[0050] Figure 9 This is a schematic diagram of the structure of a computer device provided in an embodiment of this application. Detailed Implementation

[0051] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0052] This application proposes a hybrid encoder architecture that integrates CNN and Mamba to improve AAE (Automatic Image Processing). CNN is used to capture local features between adjacent sensors, while Mamba is used to model global sensor dependencies, enabling the model to obtain more stable and discriminative latent representations even with small sample sizes. Simultaneously, the proposed data generation framework can generate high-quality fault samples without additional sample filtering, significantly improving the practicality of FDD (Fault-Driving Detection) systems.

[0053] To make the above-mentioned objectives, features and advantages of this application more apparent and understandable, the application will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0054] In one exemplary embodiment, such as Figure 7 As shown, a method for generating fault data of a chiller is provided. This method is executed by a computer device, specifically by a computer device such as a terminal or a server alone, or by a terminal and a server together. In the embodiments of this application, the method includes the following steps.

[0055] Step 701: Obtain noise data and the corresponding category label for the chiller.

[0056] Step 702: The noise data and the category label corresponding to the chiller are used to generate synthetic fault data using a trained fault data generation module; the synthetic fault data is used to train the fault diagnosis module for fault diagnosis; the trained fault data generation module includes a self-adversarial encoder, a discriminator, and a decoder.

[0057] The training process of the fault data generation module specifically includes:

[0058] Obtain the actual fault data and the corresponding category labels for the actual fault data.

[0059] The input sequence of the self-adversarial encoder is determined based on the actual fault data and the category labels corresponding to the actual fault data.

[0060] Based on the input sequence, the local feature subspace is extracted using the local modeling branch of the self-adversarial encoder.

[0061] The global feature subspace is extracted based on the input sequence using the global modeling branch of the self-adversarial encoder.

[0062] The local feature subspace and the global feature subspace are fused and linearly mapped to obtain latent variables.

[0063] The latent variables and prior distributions are input into the discriminator and decoder of the fault data generation module, respectively. The fault data generation module is trained based on the overall loss function obtained from the prior distribution and gradient penalty term, with the synthetic data as the output. The synthetic data is simulated synthetic fault data.

[0064] By implementing the above steps, synthetic fault data is generated through the fault data generation module. In the fault data generation module, the local modeling branch of the self-adversarial encoder extracts the local feature subspace and captures local features, and the global modeling branch extracts the global feature subspace and captures global features. This enables the fault data generation module to obtain a more stable latent representation with small samples. At the same time, the fault data generation module can generate high-quality fault samples without additional sample screening.

[0065] In practical applications, the local modeling branch is a one-dimensional convolutional structure. The global modeling branch is a Mamba structure.

[0066] In an exemplary embodiment, the extraction of the global feature subspace based on the input sequence using the global modeling branch of the self-adversarial encoder specifically includes: representing the input sequence in a continuous state space; discretizing the input sequence represented in the continuous state space to obtain a discretized input sequence; and expanding the state space model based on the discretized input sequence to obtain the global feature subspace.

[0067] In practical applications, the chiller fault data generation method further includes: inputting the synthesized fault data into a classifier to obtain fault diagnosis results.

[0068] This application enables stable generation of samples in small-sample scenarios by leveraging the distribution approximation capability of AAE, avoiding the screening mechanisms relied upon by traditional methods and effectively improving the quality of faulty samples. Based on a hybrid encoder architecture of CNN and Mamba, it integrates local feature extraction and global dependency modeling capabilities, enabling the learning of stable and highly generalizable latent representations in small-sample scenarios, thereby improving the realism and distribution consistency of generated samples.

[0069] Accurate and effective fault diagnosis strategies are crucial for timely detection of abnormal states in chiller units, thereby reducing energy waste. However, the scarcity of chiller unit fault samples leads to significant distribution bias and insufficient representation problems in data-driven fault detection and diagnosis methods under small sample conditions. To alleviate this challenge, this paper proposes a multi-scale feature encoding-driven adversarial autoencoder framework (CMamba-AAE) based on CNN and Mamba. This method combines the local correlation modeling capability of CNN with the global dependency representation capability of Mamba state-space model, and achieves controllable alignment of prior distribution through the latent space adversarial constraint of AAE, enhancing the stability of the generation process. Experiments on the ASHRAE 1312-RP dataset show that the proposed model performs outstandingly in small sample scenarios. When there are only n=5 real samples for each fault class, CMamba-AAE achieves the highest FDD accuracy of 96.05% across the four fault levels, improving upon the suboptimal model by 19.44%–26%. Furthermore, the generated samples can be directly used for training without screening, significantly improving data utilization.

[0070] In another exemplary embodiment, this application also provides a chiller fault data generation method to address the problem of insufficient real fault data. The overall framework is as follows: Figure 1 As shown, the framework consists of two main modules: a fault data generation module and an FDD module. First, a small amount of real fault data is used as the training dataset, and combined with label information, it is input into the self-adversarial encoder CMamba to obtain latent variables with rich feature information. The encoder in this application is a self-adversarial encoder. Next, the latent variables are input into two different branch structures. In the discriminator branch, a standard prior distribution (such as a Gaussian distribution) is introduced, and the distribution of the latent variables is constrained to approximate this prior distribution, making the structure of the latent variables more controllable. In the decoder branch, the latent variables are "reconstructed" into the input data, and the reconstruction loss is calculated to train the decoder's generation ability. The decoder generates reconstructed data. Then, randomly sampled noise data and class labels from the standard space are input into the trained fault data generation module to generate a large amount of synthetic fault data, which is then merged with the training data to form a new training dataset. Finally, the expanded dataset and the test dataset are input into the classifier to obtain the FDD results.

[0071] The limitations of GANs and VAEs result in some abnormal and unusable samples in their generated datasets. Therefore, FDD methods based on GANs and VAEs typically require a sample selection mechanism to pick out high-quality samples from the large amount of generated data. Figure 2 As shown in (a) in the figure, Figure 2 (a) in the diagram is a flowchart of a traditional generative model fault diagnosis method. However, due to its superior generative capabilities, AAE (Automatic Image Processing) can be directly used in FDD (Fault Diagnosis) without the need for sample filtering. Therefore, this application proposes an AAE-based FDD process for HVAC systems, as follows: Figure 2 As shown in (b) in the figure, Figure 2 (b) in the diagram is a flowchart of a fault diagnosis method based on the Mamba model, which achieves end-to-end high-quality fault data generation without a screening process. Adversarial autoencoders (AAEs) incorporate the distribution learning process of the latent space into the training objective, enabling... To impose on the encoder output The prior distribution, The input is the raw fault data without tag information. The calculation of the aggregated posterior distribution is given by formula (1), which enables the model to actively learn the true distribution of the data during the encoding process, mapping the complex data to the latent space. By analyzing latent variables With any prior distribution Perform distribution regularization to guide the encoder to output latent variables that conform to the true distribution.

[0072] (1)

[0073] Meanwhile, the autoencoder also attempts to minimize reconstruction errors. Through the synergistic optimization of reconstruction loss and adversarial loss, the AAE model actively achieves data distribution approximation and feature preservation during training. The model itself has the ability to filter low-quality samples, ensuring that every output sample can be effectively used for downstream fault classification tasks.

[0074] Adversarial autoencoders (AAEs), through adversarial matching of the latent space, can more comprehensively cover the data distribution, increase the expressive power of sparse patterns, and thus generate highly diverse and high-fidelity fault samples. Compared with GANs, AAEs not only generate high-quality samples but also possess reconstruction capabilities; compared with VAEs, AAEs generate data with higher fidelity, clearer sample boundaries, avoid ambiguity issues, and improve the fitting ability to complex distributions. In summary, the no-selection fault data generation method proposed in this application fully leverages the distribution matching capability of adversarial autoencoders, avoids the dependence on subsequent selection processes in traditional methods, and establishes a new paradigm for efficient and reliable fault data generation, providing better training data support for HVAC fault detection and diagnosis tasks.

[0075] This application systematically improves the encoder structure, proposing a dual-branch encoder architecture combining convolutional neural networks and the Mamba state-space model. This aims to achieve collaborative modeling of local features and global sequence dependencies, thereby enhancing the diversity and realism of the latent space representation. The detailed structure of CMamba-AAE is as follows: Figure 3 As shown. Specifically, to address the issue of local correlation in fault data, this application introduces a convolution branch in the encoder. This branch employs a one-dimensional convolution operation, where the convolution kernel processes the input data by sliding its receptive field, locally extracting the feature relationships between multiple sensor variables. For example, the temperature and pressure sensors in a chiller unit have a strong physical correlation, and the convolution operation can effectively capture this spatial correlation information. For the input sequence... The convolution branch first passes through a one-dimensional convolution kernel with a receptive field of k and the number of channels of h. Obtain the local feature subspace :

[0076] (2)

[0077] in, Indicates the sequence length. Representing feature dimension, This represents the convolution operation. This represents the activation function. This represents the convolution bias, where R is a real number.

[0078] However, the chiller unit fault data consists of 65 sensor data points, which correspond to the operating parameters of different parts of the system. Furthermore, all parameters imply implicit relationships between various components, exceeding the capabilities of the local receptive field of the convolutional neural network. To address this issue, this application innovatively introduces the Mamba structure as the global modeling branch of the encoder. Mamba is an efficient sequence modeling framework based on a state-space model (SSM), and its continuous system can be represented by formula (3). and Represent the continuous-time hidden state and its derivative. As a continuous-time input, in this application it can be considered as a continuous input of 65 sensor data points. For continuous time output, Both represent continuous state space matrices:

[0079] (3)

[0080] Discretizing it yields:

[0081] (4)

[0082] in, This represents the discrete-time hidden state, and the remaining parameters are the corresponding discretized data in formula (3). It can be dynamically adjusted under the action of a selective mechanism. Expanding the SSM yields:

[0083] (5)

[0084] in, , This represents the global feature at the t-th sensor. For the input of the i-th sensor, For cross-sensor dependent kernel functions, the distance is... The sensor for the first The contribution of each sensor feature, The matrix exponentiation describes the progression of the hidden state along the sensor index direction. Propagation and mixing effects during the step.

[0085] Local feature subspace modeled by local convolution Global feature subspace modeled with SSM They are complementary in the feature space, so fused features are constructed by concatenating features. :

[0086] (6)

[0087] The merged dimensions satisfy:

[0088] (7)

[0089] Next, the fused features will be entered into the latent space via a linear mapping. .

[0090] (8)

[0091] in, To flatten the features, and These represent the weights and biases of the linear projection, respectively. The dimensions of each data feature.

[0092] Model training:

[0093] The training of an adversarial autoencoder can be divided into two parts: adversarial training of the discriminator and reconstruction training of the decoder. When the input... Latent variables were obtained using the CMamba encoder. Then, an arbitrary prior distribution will be used. Together with the discriminator network, the discriminator is trained to maximize its ability to distinguish between the prior distribution and the latent variable. The loss function can be expressed as formula (9).

[0094] (9)

[0095] in, Expressing expectations, This represents the probability of the discriminator's output for the current data. During training, the discriminator needs to output a high probability for the prior distribution and a low probability for the latent variable. Let be the target loss function of the discriminator.

[0096] Simultaneously train the encoder to make its output latent variables Approaching the prior distribution as closely as possible The discriminator can be fooled by minimizing the following loss function.

[0097] (10)

[0098] Let be the target loss function of the encoder.

[0099] Reconstruction loss This represents the difference between the original fault data and the reconstructed data, and the loss function is shown in formula (11).

[0100] (11)

[0101] in, This indicates the original fault data that was not linked to tag information. Represents the reconstructed data output by the decoder. This represents the square of the L2 norm, ensuring reconstruction accuracy. For the encoder's network parameters, These are the network parameters for the decoder.

[0102] Furthermore, to further optimize the distribution approximation process of the latent space, this application introduces Wasserstein distance instead of the traditional JS divergence in the adversarial training stage. Wasserstein distance possesses the property of being smooth and differentiable, providing more stable gradient feedback for adversarial training and alleviating the mode collapse and gradient vanishing problems in traditional adversarial training. Simultaneously, to ensure that the discriminator satisfies Lipschitz continuity, a gradient penalty term (GP) is added to the loss function. By constraining the gradient norm of the discriminator output with respect to the input samples, the smooth change of gradient during training is ensured, improving the convergence and stability of the training process. The calculation of GP is shown in Equation (12).

[0103] (12)

[0104] in, It is generated by linear interpolation between real random variables and latent variables generated by the encoder. This represents the gradient of the discriminator with respect to the interpolation point. Denotes the Euclidean norm. To represent the difference samples The mathematical expectation. Furthermore, class labels for the data were introduced during the training process. This enables the model to learn the differences between different categories of data, thereby generating the necessary fault samples.

[0105] Therefore, the overall loss function of the fault data generation module can be defined as formula (13).

[0106] (13)

[0107] in, Represents the objective function. This represents the output value of the discriminator. For the expected value, It is the discriminator itself. Represents the original The distribution of reconstructed values ​​generated by the values represent and The expected value of the difference between them. This is the original fault data without tag information. The reconstructed data output by the decoder. , is a hyperparameter. For the Euclidean norm, The output probability of the discriminator for the current data. As expected, As latent variables, As a prior distribution, This is the gradient penalty term.

[0108] This application also includes comprehensive experiments to demonstrate the superiority of the proposed method. These experiments were conducted on publicly available datasets and compared with other different generation methods. All experiments were performed under identical computer specifications: an AMD Ryzen 5 7500F CPU, 24GB RAM, an NVIDIA GeForce RTX 4090D GPU, and a Linux system. The development environment consisted of Python 3.8, TensorFlow 2.4, and PyCharm software.

[0109] Dataset and comparison method:

[0110] To verify the effectiveness of the proposed method, a chiller unit fault dataset collected from the ASHRAE-1312RP project was used. This dataset contains a total of seven typical faults, as shown in Table 1: reduced condenser water flow (F1), reduced evaporator water flow (F2), refrigerant leakage (F3), overcharged refrigerant (F4), excessive oil (F5), condenser scaling (F6), and non-condensable substances in the refrigerant (F7). Each fault is divided into four different severity levels: Level 1, Level 2, Level 3, and Level 4. The different severity levels of the fault have different effects on the chiller unit. For example, for faults F1 and F2, the four severity levels reduce the condenser flow and evaporator flow by 10%, 20%, 30%, and 40%, respectively. Each fault type across different levels contains a total of 5192 fault data points. To simulate the situation of insufficient FDD fault samples in real-world chiller units, 5, 10, 20, and 30 fault data points were selected from each fault level as the training dataset for the experiment, and 300 data samples were selected from each fault dataset as the test dataset. Because each fault sample contains 65 different data variables, to avoid excessively large or small values ​​affecting feature extraction, the data needs to be normalized before training.

[0111]

[0112] Three state-of-the-art fault data generation methods were selected: CWGAN-VAE, TransCWGAN-ENS, and MCVAE-CT. For each fault type, 1000 fault samples were generated and selected using these three methods. The CMamba-AAE model, however, eliminates the need for a selection step, allowing the generated high-quality data to be directly added to the training set for FDD.

[0113] Comparative analysis with FDD frameworks that have filtering mechanisms:

[0114] First, the FDD accuracy of the proposed model is compared with that of three comparative models with and without filtering mechanisms to demonstrate the superiority of the proposed FDD diagnostic process. The results are as follows: Figure 4 and Figure 5 As shown. Figure 4 Indicates Level-1, from Figure 4 As can be seen, after using a filtering mechanism to select high-quality data from the generated samples, the accuracy of FDD showed varying degrees of improvement under different real sample sizes. The improvement in accuracy was particularly significant when the real sample size n=5 and 10. Figure 5 Similar conclusions can be drawn from this. Furthermore, from... Figure 5 As can be seen, when the number of real samples n=5,10, the samples generated by the GAN-based model contain a large number of samples that are unfavorable to FDD. However, after using a filtering mechanism, a higher FDD accuracy can be obtained. This is because the training of GAN is unstable and prone to mode collapse, resulting in significant differences in the quality of the generated samples, thus requiring the use of a filtering mechanism for selection. The VAE-based generative model is relatively stable and can maintain stable prediction performance without using a filtering mechanism. After using a filtering mechanism, the accuracy is further improved. The CMamba-AAE model proposed in this application achieves the highest FDD accuracy without a filtering mechanism, especially when the number of real samples n=5,10, which shows that the model proposed in this application has the advantages of strong stability and high generation quality.

[0115] Furthermore, in traditional FDD methods based on filtering mechanisms, low-quality samples in the generated data are discarded, resulting in low utilization of generated data. When the training set is expanded to the same size, traditional FDD methods based on GANs and VAEs require generating more fault samples for the filtering mechanism to select from, leading to a waste of training resources. Therefore, this paper compares how many fault samples the generation model needs to synthesize when 100 usable high-quality samples are obtained, using real sample numbers n=5 and n=50 as examples. The results are shown in Tables 2 and 3. It can be seen that due to the instability of GAN training, a large number of low-quality samples exist in the generated data. Therefore, a filtering mechanism must be used to select a small number of usable samples. In contrast, the samples generated by the model in this application are all usable, effectively saving computational resources and avoiding the waste of generated data.

[0116]

[0117]

[0118] Ablation experiment:

[0119] To verify the complementarity between CNN local modeling and Mamba global modeling, the proposed model was compared with encoder structures using the original fully connected neural network, CNN-based networks, and Mamba-based networks. With real fault data sets of n=5 and 10, SVM was used as the final fault classifier to systematically verify the contributions of each component. The results are shown in Table 4. The table shows that the fully connected structure performs weakly overall, indicating that a simple linear structure cannot fully extract the feature information of the fault data. While both CNN and Mamba structures show some improvement over linear models when used alone, their performance is limited when used individually; capturing only local or global features is insufficient to fully depict the complex distribution of fault data.

[0120]

[0121] In comparison, CMamba achieved optimal results across all levels and sample sizes, with a more pronounced advantage in low-sample cases (n=5), such as an improvement of approximately 0.96% compared to Only-CNN and approximately 7.15% compared to Only-Mamba in Level-2. This indicates that the local feature extraction capability of CNN and the global modeling capability of Mamba complement each other in the feature space, thereby improving the encoder's ability to represent fault data. Furthermore, CMamba remains optimal even when the sample size increases to 10, demonstrating its good scalability.

[0122] Overall, the ablation results fully demonstrate that the fusion of CNN and Mamba can improve the quality of faulty data generation and verify the effectiveness of the CMamba architecture design.

[0123] Overall model comparison:

[0124] The proposed method is compared with methods in previous studies, and FDD performance is tested using various classifiers. Tables 5 to 8 show the FDD accuracy and F1 score for four different fault levels and four different numbers of real fault samples, with the highest scores marked in bold. It can be seen that the proposed "CMamba-AAE" model achieves the best performance in most cases, and the performance of all models gradually improves as the fault level increases and the characteristics of the fault data become more apparent. As shown in Table 5, when the number of real samples n=5, 10, and 30, the proposed CMamba-AAE model achieves the best results on all different classifiers. However, when the number of real samples n=20, MCVAE-CT, using BG as the classifier, achieves higher accuracy than the proposed method, reaching the highest diagnostic performance. Overall, compared with the other three FDD methods, the proposed CMamba-AAE model does not require filtering of the generated data and achieves the highest FDD accuracy in most cases.

[0125] Thanks to the constraint features of latent variables in AAE, the model exhibits a more significant performance advantage in small sample scenarios. As shown in Tables 5 to 8, the proposed model achieves the highest diagnostic accuracy when the number of real samples n=5 at different severity levels. This means that, compared to other comparative models that do not impose constraints on latent variables, the model proposed in this application can effectively alleviate problems such as insufficient capture of the true data distribution caused by data scarcity. Furthermore, as shown in Tables 7 and 8, the performance advantage of CMamba-AAE gradually weakens as the number of real samples increases, further confirming the model's unique advantage in small sample scenarios.

[0126] Table 5. Level-1 accuracy and F1 score for 5, 10, 20, and 30 real samples.

[0127]

[0128] Table 6. Level-2 accuracy and F1 score with 5, 10, 20, and 30 real samples.

[0129]

[0130] Table 7 shows the accuracy and F1 score of Level-3 with 5, 10, 20, and 30 real samples.

[0131]

[0132] Table 8 shows the accuracy and F1 score of Level-4 with 5, 10, 20, and 30 real samples.

[0133]

[0134] Furthermore, especially when using SVM as the classifier, the model in this application exhibits stronger performance advantages, such as... Figure 6 As shown, where, Figure 6 (a) in the figure shows the classification effect of SVM at Level-1. Figure 6 (b) in the figure shows the classification effect of SVM under Level-2. Figure 6 (c) in the figure shows the classification effect of SVM under Level-3. Figure 6 In the diagram, (d) represents the classification performance of SVM at Level-4. From... Figure 6 As can be seen, when the number of real faults n=5, the accuracy of the proposed model combined with SVM is significantly improved, with FDD accuracies reaching 82.81%, 89.19%, 85.81%, and 96.05%, respectively. Compared with the suboptimal model, these figures represent improvements of 19.44%, 26%, 11.92%, and 12.36%, respectively. This means that the proposed model can utilize the feature information of a very small number of real samples to generate high-quality fault samples. When the number of real faults n=10, the proposed model also shows a significant performance advantage. However, when the number of real faults n=20, the performance improvement of the proposed model compared to the suboptimal model is relatively limited.

[0135] In summary, the method of this application can generate higher quality and more diverse synthetic samples for fault diagnosis with only a very small number of real samples, which greatly improves the accuracy of FDD and provides a more effective solution for fault diagnosis with small samples.

[0136] The lack of sufficient fault samples has long plagued the development of HVAC FDD technology. Furthermore, traditional data augmentation techniques often suffer from unstable data generation, necessitating data filtering mechanisms to select a subset of high-quality samples. To address this issue, this application designs a novel multi-scale feature extraction adversarial autoencoder network (CMamba-AAE) to generate a sufficient number of fault samples to expand the training dataset. A discriminator network is introduced into the autoencoder training to constrain the latent variables generated by the encoder to a standard distribution, giving it a clear probability distribution structure. Simultaneously, an encoder structure with multi-scale feature extraction capabilities is designed, using one-dimensional convolution and a Mamba structure to extract local and global dependencies between variables within the real data, respectively, resulting in richer information representations of the latent variables. The proposed model eliminates the need for data filtering mechanisms, allowing the generated data to be directly added to the training set for FDD, effectively simplifying the diagnostic process and improving the utilization rate of the generated data. Experimental results show that our method achieves the best performance in chiller FDD compared to traditional models incorporating filtering mechanisms, demonstrating the stability and high availability of the data generated by our model.

[0137] Although the proposed FDD method achieves state-of-the-art FDD performance, it suffers from some shortcomings in training efficiency due to the multifaceted loss optimization involved in the training process. Furthermore, the proposed model is only applicable to chiller unit fault datasets, requiring further research to improve its generalizability.

[0138] Based on the same inventive concept, this application also provides a chiller fault data generation device for implementing the chiller fault data generation method described above. The solution provided by this device is similar to the solution described in the above method; therefore, the specific limitations in one or more chiller fault data generation device embodiments provided below can be found in the limitations of the chiller fault data generation method described above, and will not be repeated here.

[0139] In one exemplary embodiment, such as Figure 8 As shown, a chiller fault data generation device is provided, comprising:

[0140] The acquisition module is used to acquire noise data and the corresponding category labels for the chiller.

[0141] The generation module is used to generate synthetic fault data by combining the noise data and the category label corresponding to the chiller using a trained fault data generation module; the synthetic fault data is used to train the fault diagnosis module for fault diagnosis; the trained fault data generation module includes a self-adversarial encoder, a discriminator, and a decoder.

[0142] The training process of the fault data generation module specifically includes:

[0143] Obtain the actual fault data and the corresponding category labels for the actual fault data.

[0144] The input sequence of the self-adversarial encoder is determined based on the actual fault data and the category labels corresponding to the actual fault data.

[0145] Based on the input sequence, the local feature subspace is extracted using the local modeling branch of the self-adversarial encoder.

[0146] The global feature subspace is extracted based on the input sequence using the global modeling branch of the self-adversarial encoder.

[0147] The local feature subspace and the global feature subspace are fused and linearly mapped to obtain latent variables.

[0148] The latent variables and prior distributions are input into the discriminator and decoder of the fault data generation module, respectively. The fault data generation module is trained based on the overall loss function obtained from the prior distribution and gradient penalty term, with the synthetic data as the output. The synthetic data is simulated synthetic fault data.

[0149] In one exemplary embodiment, a computer device is provided, which may be a server or a terminal, and its internal structure diagram may be as follows. Figure 9 As shown, the computer device includes a processor, memory, input / output (I / O) interfaces, and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computational and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and a database. The internal memory provides the environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The database stores chiller fault data generation data. The I / O interfaces are used for information exchange between the processor and external devices. The communication interface is used for communication with external terminals via a network connection. When the computer program is executed by the processor, it implements a chiller fault data generation method.

[0150] Those skilled in the art will understand that Figure 9The structures shown are merely block diagrams of some structures related to the present application and do not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than shown in the figures, or combine certain components, or have different component arrangements. In an exemplary embodiment, a computer device is provided, including a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the above-described method embodiments.

[0151] In one exemplary embodiment, a computer-readable storage medium is provided storing a computer program that, when executed by a processor, implements the above-described method embodiments.

[0152] In one exemplary embodiment, a computer program product is provided, including a computer program that, when executed by a processor, implements the above-described method embodiments.

[0153] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of the relevant data must comply with relevant regulations.

[0154] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments described above. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM).

[0155] The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited to these.

[0156] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0157] This document uses specific examples to illustrate the principles and implementation methods of this application. The descriptions of the above embodiments are only for the purpose of helping to understand the methods and core ideas of this application. Furthermore, those skilled in the art will recognize that, based on the ideas of this application, there will be changes in the specific implementation methods and application scope. Therefore, the content of this specification should not be construed as a limitation of this application.

Claims

1. A method for generating failure data of a water chiller, characterized by, The method for generating chiller fault data includes: Obtain noise data and the corresponding category labels for the chiller; The noise data and the category labels corresponding to the chiller are used to generate synthetic fault data using a trained fault data generation module; the synthetic fault data is used to train a fault diagnosis module for fault diagnosis; the trained fault data generation module includes a self-adversarial encoder, a discriminator, and a decoder. The training process of the fault data generation module specifically includes: Obtain the actual fault data and the category labels corresponding to the actual fault data; The input sequence of the self-adversarial encoder is determined based on the actual fault data and the category labels corresponding to the actual fault data; Based on the input sequence, a local feature subspace is extracted using the local modeling branch of the self-adversarial encoder; The global feature subspace is extracted based on the input sequence using the global modeling branch of the self-adversarial encoder; the global modeling branch is a Mamba structure. The local feature subspace and the global feature subspace are fused and linearly mapped to obtain latent variables; The latent variables and prior distributions are input into the discriminator and decoder of the fault data generation module, respectively. The fault data generation module is trained based on the overall loss function obtained from the prior distribution and gradient penalty term, with the synthetic data as the output. The synthetic data is simulated synthetic fault data.

2. The chiller failure data generation method of claim 1, wherein The local modeling branch is a one-dimensional convolutional structure.

3. The chiller failure data generation method of claim 1, wherein Based on the input sequence, a global feature subspace is extracted using the global modeling branch of the self-adversarial encoder, specifically including: The input sequence is represented in a continuous state space; Discretize the input sequence represented in continuous state space to obtain the discretized input sequence; The state-space model is expanded based on the discretized input sequence to obtain the global feature subspace.

4. The chiller fault data generation method according to claim 1, characterized in that, The expression for the overall loss function is: ; in, Let be the objective function. For the discriminator output value, As the expected value, For the discriminator itself, for and The expected value of the difference between them. For the original The distribution of reconstructed values ​​generated by the values This is the original fault data without tag information. The reconstructed data output by the decoder. For hyperparameters, For the Euclidean norm, The output probability of the discriminator for the current data. As latent variables, As a prior distribution, This is the gradient penalty term.

5. The chiller fault data generation method according to claim 1, characterized in that, Also includes: The synthesized fault data is input into a classifier to obtain fault diagnosis results.

6. A chiller fault data generation device, characterized in that, The chiller fault data generation device includes: The acquisition module is used to acquire noise data and the category labels corresponding to the chiller. A generation module is used to generate synthetic fault data from the noise data and the category label corresponding to the chiller using a trained fault data generation module; the synthetic fault data is used to train a fault diagnosis module for fault diagnosis; the trained fault data generation module includes a self-adversarial encoder, a discriminator, and a decoder. The training process of the fault data generation module specifically includes: Obtain the actual fault data and the category labels corresponding to the actual fault data; The input sequence of the self-adversarial encoder is determined based on the actual fault data and the category labels corresponding to the actual fault data; Based on the input sequence, a local feature subspace is extracted using the local modeling branch of the self-adversarial encoder; The global feature subspace is extracted based on the input sequence using the global modeling branch of the self-adversarial encoder; the global modeling branch is a Mamba structure. The local feature subspace and the global feature subspace are fused and linearly mapped to obtain latent variables; The latent variables and prior distributions are input into the discriminator and decoder of the fault data generation module, respectively. The fault data generation module is trained based on the overall loss function obtained from the prior distribution and gradient penalty term, with the synthetic data as the output. The synthetic data is simulated synthetic fault data.

7. A computer device, comprising: A memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that the processor executes the computer program to implement the chiller fault data generation method according to any one of claims 1-5.

8. A computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the computer program implements the chiller fault data generation method according to any one of claims 1-5.

9. A computer program product, comprising a computer program, characterized in that, When executed by a processor, the computer program implements the chiller fault data generation method according to any one of claims 1-5.

Images