Water chilling unit fault diagnosis system based on MATE-Net and edge deployment method

Abstract

The invention discloses a water chilling unit fault diagnosis system based on MATE-Net and an edge deployment method, and belongs to the technical field of industrial intelligent operation and maintenance and fault diagnosis. Local fluctuation and global trend characteristics of working conditions are adaptively extracted through a parallel double-path multi-scale convolutional layer, and weights of key thermal parameters are automatically enhanced in combination with an SE-Block attention mechanism; a long-distance time sequence dependency relationship of the thermal process is effectively modeled by using a large receptive field of a time domain convolutional network (TCN), and deep features are extracted and input into a hybrid integrated voting classifier formed by Softmax, SVM and LightGBM for joint decision making; finally, through INT8 model quantification and a multi-thread parallel reasoning technology based on a security queue, an algorithm is deployed in an industrial edge gateway, and millisecond-level end-side real-time diagnosis and cloud edge cooperative control of faults such as refrigerant leakage and condenser scaling are realized.

Description

Technical Field

[0001] This invention belongs to the field of industrial intelligent operation and maintenance and fault diagnosis technology, specifically involving a fault diagnosis system for chiller units based on MATE-Net and an edge deployment method. Background Technology

[0002] Currently, with the acceleration of global industrialization and urbanization, large-scale central air conditioning systems are widely used in commercial buildings, data centers, and industrial plants. Chillers, as core energy-consuming equipment, typically account for more than 50% of the total energy consumption of the entire air conditioning system. Therefore, the operation and maintenance management and energy-saving optimization of chillers have attracted much attention. As a crucial component of building energy conservation and industrial temperature control, the healthy and efficient operation of chillers directly impacts enterprise operating costs and the implementation of the national "dual-carbon" strategy. Therefore, research on chiller fault diagnosis technology is extremely important. Only by improving the intelligent operation and maintenance level of equipment can we further promote the upgrading of industrial energy management systems. Data-driven fault diagnosis is an important branch of industrial artificial intelligence, aiming to interpret and understand equipment status from multi-dimensional sensor data. Fault identification, as one of its core tasks, aims to identify abnormal patterns in unit operation and classify the causes of faults. In recent years, the introduction of deep learning technology has greatly promoted the development of predictive maintenance in industry. However, as a typical complex thermodynamic system, chiller units exhibit highly nonlinear, strongly coupled, and thermally inertial characteristics in their operating parameters (such as temperature, pressure, and flow rate), placing extremely high demands on real-time diagnostic algorithms. Diagnostic systems need to be able to decouple features from complex coupled data and capture long-term temporal dependencies. Furthermore, traditional manual inspection methods are inefficient and have blind spots, failing to achieve 24 / 7 coverage, while fixed sensors struggle to capture visual anomalies such as instrument readings or minor leaks. Deep learning can achieve higher accuracy than traditional physical models for detecting multivariable, long-term, and subtle fault characteristics in chiller units. Therefore, utilizing advanced deep neural networks combined with mobile sensing to replace manual inspections for early fault warning and location has become a hot topic in modern industrial technology.

[0003] Existing chiller unit fault diagnosis systems have the following problems:

[0004] 1. Traditional monitoring systems based on mechanistic models or single thresholds have high false alarm rates and rely heavily on fixed-point sensors, making it difficult to effectively handle complex coupling relationships between multiple variables and detect early minor faults and abnormal changes in equipment appearance.

[0005] 2. Existing deep learning diagnostic models mostly use single-scale convolutional neural networks (CNNs), which make it difficult to simultaneously capture both short-term operating condition fluctuations and long-term performance degradation trends in chiller unit operating data, resulting in incomplete feature extraction.

[0006] 3. Conventional Long Short-Term Memory (LSTM) networks are computationally inefficient and prone to gradient vanishing problems when processing long sequence data with large thermal inertia, such as that of chiller units, and cannot meet real-time requirements.

[0007] 4. Traditional AI-powered operation and maintenance solutions heavily rely on cloud servers for data analysis, which means that massive amounts of high-frequency sensor data and video streams need to be uploaded in real time, resulting in high bandwidth costs, high data transmission latency, and the risk of privacy leaks of core enterprise energy consumption data. At the same time, the simple single-threaded processing mechanism at the edge is prone to resource blockage when dealing with multimodal data, affecting the real-time performance of diagnostics. Summary of the Invention

[0008] To address the aforementioned problems, this invention proposes a fault diagnosis system for chiller units based on MATE-Net, characterized by comprising:

[0009] An industrial monitoring component, comprising an industrial camera corresponding to a chiller unit, and a pan-tilt unit mechanically connected to the industrial camera;

[0010] A mobile inspection device, which is connected to the industrial monitoring component, is used to send pan-tilt control commands to the pan-tilt unit to adjust the shooting angle of the industrial camera, and to send angle control commands to the industrial camera.

[0011] An edge computing device is bidirectionally connected to the mobile inspection device. It is used to receive the multimedia data stream of the chiller unit transmitted by the mobile inspection device, and to perform edge inference on the multimedia data stream using the MATE-Net algorithm to obtain the structured fault monitoring data of the chiller unit. At the same time, it sends motion control signals to the mobile inspection device to schedule the inspection actions of the mobile inspection device.

[0012] The smart industrial platform interacts bidirectionally with the edge computing device through a cloud-edge collaboration mechanism. It is used to receive structured fault monitoring data uploaded by the edge computing device and to issue remote control commands to the edge computing device to regulate the operation of the fault diagnosis system.

[0013] An edge deployment method for chiller unit fault diagnosis based on MATE-Net includes the following steps:

[0014] S1. Data Acquisition and Experiment Construction;

[0015] S2, Data Cleaning and Feature Engineering;

[0016] S3. Construct and improve the MATE-Net network structure;

[0017] S4. Train the network model and optimize the classifier parameters using an ensemble learning strategy;

[0018] S5. Perform quantization conversion on the model and then perform accuracy calibration.

[0019] S6. Deploy to the edge computing gateway for multi-threaded real-time diagnostics.

[0020] In step S1, the ASHRAE RP-1043 standard dataset is used as the basis for model training and validation. It covers the normal operation data of the unit under different load rates, as well as the operation data of seven typical thermal faults introduced by humans (including condenser scaling, evaporator scaling, refrigerant leakage, excessive refrigerant charge, reduced condensate flow, reduced evaporation flow, and non-condensable gases in the refrigerant) under four different severity levels.

[0021] In step S2, the raw sensor data in the RP-1043 dataset is preprocessed:

[0022] Feature screening: Key variables strongly correlated with the thermodynamic cycle were screened from the original 64 channels: evaporation temperature, condensation temperature, suction pressure, discharge pressure, compressor power, and chilled water supply and return temperatures;

[0023] Outlier handling: Remove outliers generated during the experiment due to sensor calibration or communication interference;

[0024] Sliding window segmentation: To address the timing characteristics of RP-1043, a sliding window technique is used to segment continuous time series into fixed-length sample segments to adapt to the input requirements of MATE-Net.

[0025] Standardization: The segmented data is standardized using Z-Score to eliminate distribution differences between different units.

[0026] In step S3, a backbone network combining dual-path multi-scale convolution and TCN is designed so that the network is dedicated to processing strongly coupled thermal data of chiller units. The chiller unit diagnostic function is deployed on the edge gateway with limited computing resources. In these settings, long-distance temporal dependencies are effectively captured and the amount of computation is controlled.

[0027] First, the limitation of a fixed receptive field at a single scale is addressed by using dual-path parallel one-dimensional convolutional layers (Dual-Path 1D-CNN). Let the input time series be X, and features are extracted using convolutional layers with kernel sizes of 3 and 5, respectively, as shown in the following formulas:

[0028] Y small =σ(BN(Conv1D) k＝3 (X)))

[0029] Y large =σ(BN(Conv1D) k＝5 (X)))

[0030] Where X represents the input multivariate time series sample of the chiller unit, Conv1D k＝3 (·and Conv1D) k＝5 (·) represent one-dimensional convolution operations with kernel sizes of 3 and 5, respectively; BN(·) is the batch normalization layer; σ(·) is the ReLU activation function; Y small and Y large The outputs are the convolutional features for the small receptive field path and the large receptive field path, respectively. Through the dual-scale convolutional structure, the model can simultaneously capture high-frequency features such as instantaneous changes in operating conditions and low-frequency features such as slowly evolving periodic trends, thereby improving the sensitivity to early fault characteristics.

[0031] Secondly, an SE-Block attention mechanism is introduced to automatically weight key thermodynamic parameter channels. Since the contribution of each parameter of the chiller unit to the fault is different, the channel features are recalibrated through global compression Squeeze and excitation operations. Let the feature map be U, and its output weight s is calculated as follows:

[0032] s = F ex (z,W)=σ(W2δ(W1z))

[0033] Where U is the channel feature map output by the convolutional layer, z is the channel statistics vector obtained by global average pooling of U, and F ex (·) represents the activation function, W1 and W2 are the weight matrices of the two fully connected layers, δ(·) is the ReLU activation function, σ(·) is the Sigmoid activation function, and s is the generated channel attention weight vector. The feature map is weighted by channels, and "·" indicates element-wise multiplication by channel. By applying adaptive weights to different channels, this module can highlight the thermal parameter channels that are more critical for fault diagnosis, suppress redundant or noisy features, and thus improve the discriminativeness and robustness of feature representation. Furthermore, to address the large hysteresis problem caused by thermal inertia, a temporal convolutional network (TCN) module is introduced. TCN exponentially expands the receptive field without increasing the number of parameters through dilated convolution. For the input sequence x, the convolution operation with dilation coefficient d is defined as:

[0034]

[0035] Where x represents the input time-series feature, f is a one-dimensional convolution kernel of length k, k is the kernel size, d is the dilation coefficient, "*(d)" indicates a causal convolution operation with dilation coefficient d, F(s) is the convolution output at time step s, i is the kernel internal index, and s is the current time position index. By introducing dilated convolution in the time dimension and expanding the receptive field layer by layer, the TCN module can efficiently model the dynamic dependencies over long time spans in chiller unit operation data while maintaining causality, thus more accurately depicting the fault evolution process. This design stacks multiple TCN blocks, with the dilation coefficient d increasing exponentially with the number of layers (e.g., 1, 2, 4), thereby covering the complete fault evolution cycle of the chiller unit.

[0036] Finally, a hybrid ensemble voting mechanism was designed at the classification decision layer; to address the poor robustness of a single Softmax classifier, the deep feature vector V output by the TCN was extracted. deep The data are input into three heterogeneous classifiers respectively:

[0037] P softmax =Softmax(W s ·V deep +b s )

[0038] P svm =SVM_Proba(V deep )

[0039] P lgbm =LightGBM_Predict(V deep )

[0040] Final fault determination result Y final The following conclusions were drawn using a weighted soft voting strategy:

[0041] Y final =argmax(αP softmax +βP svm +γP lgbm ).

[0042] Among them, V deep W is the deep feature vector extracted by the backbone network. s and b s These are the weight matrix and bias vector of the Softmax classifier, respectively, where Softmax(·) is the Softmax activation function, and P... softmax P is the fault category probability vector output by the Softmax classifier. svm For the fault category probability estimate P obtained based on support vector machine, lgbm For fault category probability prediction based on LightGBM, α, β, and γ are the weighting coefficients of the three classifiers, and argmax(·) represents the category index corresponding to the maximum weighted probability. final This module labels the final fault diagnosis results. By integrating weighted soft voting from three classifiers—deep neural networks, support vector machines, and gradient boosting trees—this module can fully combine the discriminative advantages of different models, thereby improving the robustness and overall accuracy of chiller unit fault diagnosis.

[0043] In step S5, the model conversion and quantization operations performed in S5 are as follows:

[0044] A1. Prepare the trained MATE-Net model and export it as an ONNX universal format file;

[0045] A2. Use the toolchain provided by the edge chip manufacturer to load the ONNX model and perform computation graph optimization and operator fusion;

[0046] A3. Collect representative chiller unit operation datasets for model quantization calibration;

[0047] A4. Perform PTQ quantization calibration using the prepared dataset, determine the optimal quantization threshold for each layer activation value through KL divergence analysis, and convert the FP32 weights to INT8 format.

[0048] A5. The toolchain uses simulation inference to compare the cosine similarity of each layer before and after quantization, and fine-tunes the quantization parameters to ensure that the accuracy loss is within an acceptable range.

[0049] A6. Compile the quantized model into a binary file specific to the edge gateway, and simulate deployment to test whether the memory usage and inference time are acceptable.

[0050] In step S6, the multi-threaded processing steps for S6 are as follows:

[0051] B1. Prepare the operating environment on the industrial edge gateway and install the corresponding NPU driver and inference library;

[0052] B2. Initialize the inference engine, load the quantized MATE-Net model file, and request NPU computing resources;

[0053] B3. Initialize the thread pool in the main thread and configure the ratio of data preprocessing threads to inference threads according to the number of sensor channels and sampling frequency;

[0054] B4. Add a thread-safe data queue. The acquisition thread reads PLC data in real time and stores it in the queue. The inference thread obtains time window data from the queue, calls the NPU to perform inference, and initially obtains the fault probability and category.

[0055] B5. In the main thread, summarize the reasoning results, execute the integrated voting logic, and if a fault is confirmed, trigger the alarm thread to write the results to the local database and push them to the monitoring dashboard.

[0056] The beneficial effects of this invention are as follows: This invention proposes a fault diagnosis system for chiller units based on MATE-Net and a method for deploying edge computing devices, achieving high-precision, low-latency real-time fault diagnosis at the end side. Compared with existing technologies, this invention has significant differences and advantages in the following aspects:

[0057] 1. The innovative MATE-Net (Multi-scale Attention Temporal Ensemble Network) model is adopted. This model adaptively extracts local fluctuation and global trend features through parallel dual-channel convolution (3x3 and 5x5 convolution kernels), and automatically selects key thermal parameter channels by combining the SE-Block attention mechanism, which effectively solves the feature extraction problem caused by the strong coupling of chiller unit parameters.

[0058] 2. A Temporal Convolutional Network (TCN) module is introduced, which uses dilated convolution to obtain a large receptive field, effectively capturing long-distance time series dependencies in the thermodynamic process of chiller units. Compared with traditional RNN / LSTM models, it significantly improves parallel computing efficiency while ensuring accuracy.

[0059] 3. A hybrid ensemble voting strategy based on Softmax, SVM and LightGBM was designed, which abandons the limitations of a single classifier and significantly improves the robustness and diagnostic accuracy of the model when facing small sample faults (such as rare faults) in chiller units.

[0060] 4. The algorithm was quantized and deployed in a multi-threaded parallel manner on edge computing devices. MATE-Net was converted to INT8 format using model compression technology and deployed on the NPU of an industrial inspection vehicle. A multi-threaded pipeline architecture based on a secure queue was designed to achieve "mobile data acquisition, local inference, and real-time closed-loop processing." This not only eliminates dependence on cloud computing power and saves network bandwidth costs, but also ensures millisecond-level fault response speed and absolute security of enterprise data, making it suitable for widespread use in scenarios such as unattended data centers and underground energy stations. Attached Figure Description

[0061] Figure 1 This is a schematic diagram of the overall hardware architecture and data interaction flow of the intelligent fault diagnosis system for chiller units provided in this embodiment of the invention.

[0062] Figure 2 This is a flowchart illustrating the overall technical route of the chiller unit fault diagnosis and edge deployment method of the present invention.

[0063] Figure 3 This is a diagram of the multi-threaded parallel processing and NPU inference software logic architecture used in the edge computing gateway of this invention.

[0064] Figure 4 This is a schematic diagram of the overall structure of the MATE-Net deep hybrid neural network model proposed in this invention.

[0065] Figure 5 This is a comparative analysis of the fault diagnosis performance metrics of the MATE-Net (labeled as M1DCNN-TCN in the figure) model of the present invention with traditional machine learning and other deep learning models. Detailed Implementation

[0066] To address the issues of high false alarm rates, difficult feature extraction, and cloud dependency encountered in the aforementioned chiller unit fault diagnosis systems, we designed and implemented an intelligent chiller unit monitoring and diagnosis system based on high-performance edge computing and a deep hybrid algorithm. The training dataset for this system simulates multivariate time-series data (including chilled / cooling water temperature, pressure, flow rate, and power) collected by high-frequency industrial sensors under various operating conditions. This data reflects the complex thermodynamic changes within the unit, significantly reducing noise caused by sensor drift or communication packet loss, which is crucial for achieving high-precision diagnosis. Sensors connect to an edge computing gateway via the Modbus / PLC protocol, reading register data and performing real-time preprocessing through multi-threading. The edge gateway is integrated with the chiller control cabinet, enabling dynamic adjustment of early warning strategies or generation of control suggestions based on diagnostic results. The edge gateway employs an industrial-grade computing platform equipped with a high-performance NPU (such as an RK3588 or equivalent chip), deploying the MATE-Net model on the edge NPU using the RKNN (Rockchip Neural Network) or TensorRT toolchain. This toolchain maximizes hardware performance and significantly reduces inference latency for deep learning models when processing long sequences of data. Leveraging MATE-Net's excellent feature extraction capabilities and ensemble decision-making mechanism, it quickly and accurately identifies faults such as refrigerant leaks, scaling, and abnormal oil temperatures.

[0067] Multithreaded execution effectively utilizes the computing resources of the multi-core CPU of the edge gateway, improving the throughput of multi-channel sensor data and system response time through parallel processing. In real-time fault monitoring applications, the processing of each sampling cycle includes steps such as data cleaning, normalization, neural network inference, and alarm logic processing. Through multithreaded design, these tasks can be distributed to different threads, achieving smoother data flow and millisecond-level diagnostic response. The main thread is responsible for polling data from the PLC / sensors, while multiple worker threads are responsible for processing these data fragments, achieving parallel computation and control. The multithreaded control in this embodiment includes the following steps:

[0068] 1. Create multiple threads: The processing unit creates multiple threads, each of which can execute different tasks simultaneously. The tasks in this invention mainly include sensor data acquisition, NPU inference engine invocation, feature preprocessing, fault classification decision, and log storage and reporting.

[0069] 2. Task allocation: The processing unit assigns different tasks to different threads so that data I / O and model calculation can be performed simultaneously.

[0070] 3. Thread synchronization: The processing unit can use mutexes or semaphores to ensure that multiple threads can safely and orderly share real-time operating data in memory.

[0071] 4. Thread communication: The thread communication mechanism ensures the coordinated operation of the acquisition thread and the inference thread. The addition of a safety queue allows time-series data packets to be safely added and retrieved by multiple threads.

[0072] 5. Thread Pool Management: The processing unit maintains a thread pool through ThreadPoolExecutor, which allows multiple diagnostic tasks to be executed concurrently (such as monitoring multiple units at the same time), while controlling the number of active threads to reduce system overhead and make the application more stable in long-term operation.

[0073] 6. Thread destruction: The processing unit can destroy threads when the diagnostic task ends or the service restarts to release memory resources.

[0074] Compared with traditional single-threaded polling, the multi-threaded control in this embodiment of the invention can improve the system's concurrent processing capability and ensure that the inference of the MATE-Net model does not block under high-frequency data acquisition.

[0075] MATE-Net (Multi-scale Attention Temporal Ensemble Network) is the core algorithm model proposed in this invention. It combines multi-scale convolution, attention mechanisms, temporal convolutional networks, and ensemble learning strategies. MATE-Net aims to provide a highly generalizable and robust framework for fault diagnosis of complex thermal systems on edge devices. MATE-Net's network architecture is specifically designed to address the issues of strong coupling of chiller parameters and thermal inertia hysteresis. This includes parallel multi-scale feature extraction layers, adaptive channel attention modules, and long temporal dependency modeling branches. Compared to traditional models, MATE-Net uses an ensemble voting mechanism to handle few-sample faults, enabling the model to perform well even with rare faults or imbalanced data, thereby improving the system's practicality.

[0076] A fault diagnosis system for chiller units based on MATE-Net and a method for deploying edge computing devices are disclosed, primarily for real-time monitoring of chiller units using edge computing devices. The fault diagnosis system includes the following steps:

[0077] S1. Data Acquisition and Experiment Construction: The ASHRAE RP-1043 standard dataset was used as the basis for model training and validation. This dataset was collected from a 90-ton centrifugal chiller test bench, covering normal operation data of the unit under different load rates (e.g., 25%–100%), as well as operation data of seven typical artificially introduced thermal faults (including condenser scaling, evaporator scaling, refrigerant leakage, excessive refrigerant charge, reduced condensate flow rate, reduced evaporate flow rate, and non-condensable gases in the refrigerant) at four different severity levels.

[0078] S2. Data Cleaning and Feature Engineering: Preprocess the raw sensor data in the RP-1043 dataset.

[0079] Feature screening: Select key variables that are strongly correlated with the thermodynamic cycle (such as evaporation temperature, condensation temperature, suction pressure, discharge pressure, compressor power, chilled water supply and return temperatures, etc.) from the original 64 channels.

[0080] Outlier handling: Remove outliers caused by sensor calibration or communication interference during the experiment.

[0081] Sliding window segmentation: To address the timing characteristics of the RP-1043, a sliding window technique is used to divide the continuous time series into sample segments of fixed length (e.g., a window length of 64 or 128 time steps) to adapt to the input requirements of MATE-Net.

[0082] Standardization: The segmented data is Z-score standardized to eliminate distribution differences between different units (such as temperature and pressure).

[0083] S3. Construct and improve the MATE-Net network structure.

[0084] S4. Train the network model and optimize the classifier parameters using an ensemble learning strategy.

[0085] S5. Perform quantization conversion on the model and then perform accuracy calibration.

[0086] S6. Deploy to the edge computing gateway for multi-threaded real-time diagnostics.

[0087] Improvements to S3 include the design of a backbone network combining dual-path multi-scale convolution and TCN, making this network dedicated to processing strongly coupled thermal data from chiller units. Chiller unit diagnostics are deployed on edge gateways with limited computing resources; in these environments, effectively capturing long-distance temporal dependencies and controlling computational load are crucial. To enhance the model's sensitivity to minor faults (such as early scaling), this design focuses on multi-scale feature fusion and channel attention.

[0088] First, the limitation of a fixed receptive field at a single scale is addressed by using dual-path 1D-CNN (dual-path parallel one-dimensional convolutional layers). Let the input time series be X, and features are extracted using convolutional layers with kernel sizes of 3 and 5, respectively, as shown in the following formulas:

[0089] Y small =σ(BN(Conv1D) k＝3 (X)))

[0090] Y large =σ(BN(Conv1D) k＝5 (X)))

[0091] Where σ is the ReLU activation function and BN is batch normalization. This allows the model to simultaneously capture transient changes (high-frequency features) and periodic trends (low-frequency features) in the operating conditions.

[0092] Secondly, an SE-Block attention mechanism is introduced to automatically weight key thermodynamic parameter channels. Since the contribution of each parameter to the fault varies within the chiller unit, channel characteristics are recalibrated through Squeeze (global compression) and Excitation operations. Let the feature map be U, and its output weight s is calculated as follows:

[0093] s = F ex (z,W)=σ(W2δ(W1z))

[0094] Where z is the statistic obtained through global average pooling, W1 and W2 are the weights of the fully connected layer, δ is ReLU, and σ is Sigmoid. The final output is Adaptive focus on key sensor data was achieved. Furthermore, to address the large hysteresis problem caused by thermal inertia, a temporal convolutional network (TCN) module was introduced. TCN exponentially expands the receptive field without increasing the number of parameters through dilated convolution. For an input sequence x, the convolution operation with dilation coefficient d is defined as:

[0095]

[0096] Where f is the filter and k is the filter size. This design stacks multiple TCNBlocks, and the expansion coefficient d increases exponentially with the number of layers (e.g., 1, 2, 4), thus covering the complete failure evolution cycle of the chiller unit.

[0097] Finally, a hybrid ensemble voting mechanism was designed at the classification decision layer. To address the poor robustness of a single Softmax classifier, the deep feature vector Vdeep from the TCN output was extracted and input into three heterogeneous classifiers:

[0098] P softmax =Softmax(W s ·V deep +b s )

[0099] P svm =SVM_Proba(V deep )

[0100] P lgbm =LightGBM_Predict(V deep )

[0101] The final fault determination result, Yfinal, is obtained through a weighted soft voting strategy:

[0102] Y final =argmax(αP softmax +βP svm +γP lgbm )

[0103] This strategy significantly enhances the model's generalization ability under complex conditions. The model was trained for 200 epochs, and its fault identification accuracy on the test set was improved by 8.5% compared to the traditional LSTM and by 4.2% compared to a single CNN model, with a single inference latency controlled within 5ms.

[0104] The steps for model conversion and quantization for S5 are as follows:

[0105] A1. Prepare the trained MATE-Net model (PyTorch / TensorFlow format) and export it as an ONNX universal format file.

[0106] A2. Use the toolchain provided by the edge chip manufacturer (such as RKNN-Toolkit2 or TensorRT) to load the ONNX model and perform computation graph optimization and operator fusion.

[0107] A3. Collect representative chiller unit operation datasets (including normal and various fault samples) for model quantization calibration. These datasets should cover different load rates (Low / Medium / High) to ensure that the quantized model does not cause false alarms due to loss of accuracy.

[0108] A4. Perform PTQ (Post-Training Quantization) calibration using the prepared dataset. Determine the optimal quantization threshold for each layer's activation values ​​using KL divergence analysis, and convert the FP32 weights to INT8 format.

[0109] A5. The toolchain uses simulation inference to compare the cosine similarity of each layer before and after quantization, and fine-tunes the quantization parameters to ensure that the accuracy loss is within an acceptable range (<1%).

[0110] A6. Compile the quantized model into a binary file (.rknn or .engine) specifically for the edge gateway, and simulate deployment to test whether the memory usage and inference time are acceptable.

[0111] The steps for multi-threaded processing in S6 are as follows:

[0112] B1. Prepare the operating environment on the industrial edge gateway and install the corresponding NPU driver and inference library (such as rknn-toolkit-lite2).

[0113] B2. Initialize the inference engine, load the quantized MATE-Net model file, and request NPU computing resources.

[0114] B3. Initialize the thread pool in the main thread and configure the ratio of data preprocessing threads to inference threads according to the number of sensor channels and sampling frequency.

[0115] B4. Add a thread-safe data queue. The acquisition thread reads PLC data in real time and stores it in the queue; the inference thread retrieves time window data from the queue, calls the NPU to perform inference, and initially determines the probability and category of the fault.

[0116] B5. In the main thread, summarize the reasoning results, execute the integrated voting logic, and if a fault is confirmed, trigger the alarm thread to write the results to the local database and push them to the monitoring dashboard.

[0117] This invention studies an intelligent fault diagnosis system for chiller units, consisting of an industrial inspection vehicle, industrial cameras, an edge computing gateway, and a MATE-Net algorithm model. This system innovates upon traditional environmental monitoring by adding an airborne edge gateway supporting NPU acceleration to achieve mobile acquisition and preprocessing of multimodal thermal data, as well as real-time fault state inference. Based on the chiller unit's real-time operating data, the system utilizes the MATE-Net model for multi-scale feature analysis and outputs specific fault categories (such as refrigerant leakage, condenser scaling, etc.). This intelligent system can adaptively adjust based on the unit's historical operating habits and report health status scores in real time.

[0118] A fault diagnosis system for chiller units based on MATE-Net and an edge computing deployment method; the overall hardware architecture and data flow of the intelligent fault diagnosis system for chiller units are as follows: Figure 1 As shown, the system collects data via cameras mounted on an industrial inspection vehicle, and the data is processed by edge computing devices to achieve cloud-edge collaboration. The overall process for fault diagnosis and edge deployment is as follows: Figure 2 As shown, this covers the entire process from ASHRAE RP-1043 data processing, model building and training to final edge quantization deployment. The multi-threaded parallel processing and NPU inference logic employed on the edge computing gateway are as follows: Figure 3 As shown, by constructing a parallel architecture of acquisition threads, thread-safe queues, and inference threads, and calling the NPU core to execute the quantization model, the system's operating efficiency can be significantly improved, fully utilizing overall computing resources to achieve millisecond-level real-time diagnosis. The network structure of the MATE-Net model used is as follows: Figure 4 As shown, time-series data is first input through the InputLayer, and operating condition features at different scales are extracted using parallel dual-path multi-scale convolutional layers (Conv1D 3×3 and 5×5). Then, the SE-Block attention mechanism is introduced to automatically weight and enhance key thermal parameter channels. Subsequently, a stacked TCN Block (temporal convolutional network) is used to capture long-distance temporal series dependencies. Finally, in the decision layer, deep features are extracted and input into a hybrid ensemble voting classifier composed of Softmax, SVM, and LightGBM to further improve the accuracy and robustness in identifying complex thermal faults in chiller units. Performance comparison analysis of different algorithm models is as follows: Figure 5 As shown, the M1DCNN-TCN (MATE-Net) proposed in this invention significantly outperforms existing technologies in terms of accuracy, precision, and recall, achieving the best diagnostic results.

[0119] The method of this invention can be implemented using an embedded chip, a software module executed by a processor, or a combination of both. The software module can be located in random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable disk, CD-ROM, or any other form of storage medium known in the art.

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

Claims

1. A fault diagnosis system for chiller units based on MATE-Net, characterized in that, include: An industrial monitoring component, comprising an industrial camera corresponding to a chiller unit, and a pan-tilt unit mechanically connected to the industrial camera; A mobile inspection device, which is connected to the industrial monitoring component, is used to send pan-tilt control commands to the pan-tilt unit to adjust the shooting angle of the industrial camera, and to send angle control commands to the industrial camera. An edge computing device is bidirectionally connected to the mobile inspection device. It is used to receive the multimedia data stream of the chiller unit transmitted by the mobile inspection device, and to perform edge inference on the multimedia data stream using the MATE-Net algorithm to obtain the structured fault monitoring data of the chiller unit. At the same time, it sends motion control signals to the mobile inspection device to schedule the inspection actions of the mobile inspection device. The smart industrial platform interacts bidirectionally with the edge computing device through a cloud-edge collaboration mechanism. It is used to receive structured fault monitoring data uploaded by the edge computing device and to issue remote control commands to the edge computing device to regulate the operation of the fault diagnosis system.

2. An edge deployment method for chiller unit fault diagnosis based on MATE-Net, characterized in that, Includes the following steps: S1. Data Acquisition and Experiment Construction; S2, Data Cleaning and Feature Engineering; S3. Construct and improve the MATE-Net network structure; S4. Train the network model and optimize the classifier parameters using an ensemble learning strategy; S5. Perform quantization conversion on the model and then perform accuracy calibration. S6. Deploy to the edge computing gateway for multi-threaded real-time diagnostics.

3. The edge deployment method for chiller unit fault diagnosis based on MATE-Net as described in claim 2, characterized in that, In step S1, the ASHRAE RP-1043 standard dataset is used as the basis for model training and validation. It covers the normal operation data of the unit under different load rates, as well as the operation data of seven typical thermal faults introduced by humans (including condenser scaling, evaporator scaling, refrigerant leakage, excessive refrigerant charge, reduced condensate flow, reduced evaporation flow, and non-condensable gases in the refrigerant) under four different severity levels.

4. The edge deployment method for chiller unit fault diagnosis based on MATE-Net as described in claim 3, characterized in that, In step S2, the raw sensor data in the RP-1043 dataset is preprocessed: Feature screening: Key variables strongly correlated with the thermodynamic cycle were screened from the original 64 channels: evaporation temperature, condensation temperature, suction pressure, discharge pressure, compressor power, and chilled water supply and return temperatures; Outlier handling: Remove outliers generated during the experiment due to sensor calibration or communication interference; Sliding window segmentation: To address the timing characteristics of RP-1043, a sliding window technique is used to segment continuous time series into fixed-length sample segments to adapt to the input requirements of MATE-Net. Standardization: The segmented data is standardized using Z-Score to eliminate distribution differences between different units.

5. The edge deployment method for chiller unit fault diagnosis based on MATE-Net as described in claim 4, characterized in that, In step S3, a backbone network combining dual-path multi-scale convolution and TCN is designed so that the network is dedicated to processing strongly coupled thermal data of chiller units. The chiller unit diagnostic function is deployed on the edge gateway with limited computing resources. In these settings, long-distance temporal dependencies are effectively captured and the amount of computation is controlled. First, the limitation of a fixed receptive field at a single scale is addressed by using dual-path parallel one-dimensional convolutional layers (Dual-Path 1D-CNN). Let the input time series be X, and features are extracted using convolutional layers with kernel sizes of 3 and 5, respectively, as shown in the following formulas: AND small =σ(BN(Conv1D k＝3 (X))) AND large =σ(BN(Conv1D k＝5 (X))) Where X represents the input multivariate time series sample of the chiller unit, Conv1D k＝3 (·and Conv1D) k＝5 (·) represent one-dimensional convolution operations with kernel sizes of 3 and 5, respectively; BN(·) is the batch normalization layer; σ(·) is the ReLU activation function; Y small and Y large The convolutional feature outputs are for the small receptive field path and the large receptive field path, respectively. Through the dual-scale convolutional structure, the model simultaneously captures the high-frequency features of instantaneous changes in the operating condition signal and the low-frequency features of the slow-evolving periodic trend, thereby improving the sensitivity to early fault features. Secondly, an SE-Block attention mechanism is introduced to automatically weight key thermodynamic parameter channels. Since the contribution of each parameter of the chiller unit to the fault is different, the channel features are recalibrated through global compression Squeeze and excitation operations. Let the feature map be U, and its output weight s is calculated as follows: s=F ex (z,W)=σ(W2δ(W1z)) Where U is the channel feature map output by the convolutional layer, z is the channel statistics vector obtained by global average pooling of U, and F ex (·) represents the activation function, W1 and W2 are the weight matrices of the two fully connected layers, δ(·) is the ReLU activation function, σ(·) is the Sigmoid activation function, and s is the generated channel attention weight vector. The feature map is weighted by channels, where "·" indicates element-wise multiplication by channel. By applying adaptive weights to different channels, this module can highlight the thermal parameter channels that are more critical for fault diagnosis and suppress redundant or noisy features, thereby improving the discriminativeness and robustness of feature representation. Furthermore, to address the large hysteresis problem caused by thermal inertia, a temporal convolutional network (TCN) module is introduced. TCN exponentially expands the receptive field without increasing the number of parameters through dilated convolution. For the input sequence x, the convolution operation with dilation coefficient d is defined as: Where x represents the input time series feature, f is a one-dimensional convolution kernel of length k, k is the kernel size, and d is the dilation coefficient. (d) "" represents a causal convolution operation with an expansion coefficient d, where F(s) is the convolution output at time step s, i is the internal index of the convolution kernel, and s is the index of the current time position. By introducing dilated convolution in the time dimension and expanding the receptive field layer by layer, the TCN module can efficiently model the dynamic dependencies over long time spans in chiller unit operation data while maintaining causality, thus more accurately depicting the fault evolution process. The stacked TCN blocks have an expansion coefficient d that increases exponentially with the number of layers, thereby covering the complete fault evolution cycle of the chiller unit. Finally, a hybrid ensemble voting mechanism was designed at the classification decision layer; to address the poor robustness of a single Softmax classifier, the deep feature vector V output by the TCN was extracted. deep The data are input into three heterogeneous classifiers respectively: P softmax =Softmax(W s ·V deep +b s ) P svm =SVM_Proba(V deep ) P lgbm =LightGBM_Predict(V deep ) Final fault determination result Y final The following conclusions were drawn using a weighted soft voting strategy: Y final =argmax(αP softmax +βP svm +γP lgbm ); Among them, V deep W is the deep feature vector extracted by the backbone network. s and b s These are the weight matrix and bias vector of the Softmax classifier, respectively, where Softmax(·) is the Softmax activation function, and P... softmax P is the fault category probability vector output by the Softmax classifier. svm For the fault category probability estimate P obtained based on support vector machine, lgbm For fault category probability prediction based on LightGBM, α, β, and γ are the weighting coefficients of the three classifiers, and argmax(·) represents the category index corresponding to the maximum weighted probability. final The final fault diagnosis result is labeled; by integrating weighted soft voting of three classifiers—deep neural network, support vector machine, and gradient boosting tree—this module fully integrates the discriminative advantages of different models, thereby improving the robustness and overall accuracy of chiller unit fault diagnosis.

6. The edge deployment method for chiller unit fault diagnosis based on MATE-Net as described in claim 5, characterized in that, In step S5, the model conversion and quantization operations performed in S5 are as follows: A1. Prepare the trained MATE-Net model and export it as an ONNX universal format file; A2. Use the toolchain provided by the edge chip manufacturer to load the ONNX model and perform computation graph optimization and operator fusion; A3. Collect representative chiller unit operation datasets for model quantization calibration; A4. Perform PTQ quantization calibration using the prepared dataset, determine the optimal quantization threshold for each layer activation value through KL divergence analysis, and convert the FP32 weights to INT8 format. A5. The toolchain uses simulation inference to compare the cosine similarity of each layer before and after quantization, and fine-tunes the quantization parameters to ensure that the accuracy loss is within an acceptable range. A6. Compile the quantized model into a binary file specific to the edge gateway, and simulate deployment to test whether the memory usage and inference time are acceptable.

7. The edge deployment method for chiller unit fault diagnosis based on MATE-Net as described in claim 6, characterized in that, In step S6, the multi-threaded processing steps for S6 are as follows: B1. Prepare the operating environment on the industrial edge gateway and install the corresponding NPU driver and inference library; B2. Initialize the inference engine, load the quantized MATE-Net model file, and request NPU computing resources; B3. Initialize the thread pool in the main thread and configure the ratio of data preprocessing threads to inference threads according to the number of sensor channels and sampling frequency; B4. Add a thread-safe data queue. The acquisition thread reads PLC data in real time and stores it in the queue. The inference thread obtains time window data from the queue, calls the NPU to perform inference, and initially obtains the fault probability and category. B5. In the main thread, summarize the reasoning results, execute the integrated voting logic, and if a fault is confirmed, trigger the alarm thread to write the results to the local database and push them to the monitoring dashboard.

Images