Electricity meter self-detection and fault prediction method based on edge computing

Abstract

The present invention belongs to the technical field of electric energy meters, and specifically relates to an electric energy meter self-test and fault prediction method based on edge computing; the method comprises: step S1: a master station cloud platform sends a self-test model package matching the specifications of the electric energy meter to each edge node installed in an electric meter concentrator; the self-test model package comprises: an encrypted handshake file and an inference engine; step S2: the edge node completes a communication connection with the master station cloud platform through the encrypted handshake file, and then calls the inference engine to confirm the multidimensional weight mask as a confidence vector and output it; step S3: after the master station cloud platform receives the respective confidence vectors of all edge nodes, it uploads the output vector to the master station cloud platform, and the master station cloud platform LSTM performs cross-node time series modeling and generates a global fault prediction; the present invention improves the real-time performance and system robustness of anomaly detection.

Description

Technical Field

[0001] The present invention belongs to the technical field of electric energy meters, and specifically relates to an electric energy meter self-detection and fault prediction method based on edge computing. Background Art

[0002] In modern power systems, electricity meters, as key devices for measuring and monitoring electricity usage, are widely deployed at various user terminals and substations. With the continuous advancement of distribution automation and smart grids, the functions of electricity meters have gradually expanded from traditional energy metering to intelligent functions such as condition monitoring, anomaly detection, remote communication, self-diagnosis, and early warning. However, current self-diagnosis and fault prediction in electricity meters still face a series of key technical challenges. This is especially true in low-voltage distribution networks, where a large number of electricity meters are dispersed, coverage is limited in remote areas, communication links are limited, and operation and maintenance resources are insufficient. Traditional centralized fault detection methods are no longer sufficient.

[0003] Currently, mainstream technologies rely on cloud-based platforms to centrally process operational data uploaded by various electricity meters, such as voltage, current, active power, reactive power, energy pulses, and phase information. Once this data is aggregated to the master station system, the meter's operating status is typically analyzed and determined using methods such as time series analysis, clustering algorithms, rule comparison, or simple model reasoning. While these approaches can achieve a certain level of meter fault detection and diagnosis, they rely primarily on centralized processing by a central server, resulting in significant system bottlenecks and real-time performance disadvantages.

[0004] First, because centralized processing relies on the remote transmission of massive amounts of data, bandwidth resources become a limiting factor. This is especially true in scenarios where wireless communication environments are unstable or communication rates are limited. Data transmission delays, packet loss, and retransmissions are common, severely impacting the timeliness of fault diagnosis. Furthermore, some energy meters, due to remote installation locations or aging communication modules, experience intermittent disconnections from the master station system, further weakening the continuous diagnostic capabilities of centralized analysis. Summary of the Invention

[0005] The main purpose of this invention is to provide an edge computing-based electricity meter self-test and fault prediction method. By sending a self-test model package from the master station cloud platform to the edge node, the edge node can perform multi-scale empirical mode decomposition on the electricity meter operating data, quickly generate local confidence vectors, and achieve local self-test. The master station further constructs an adjacency graph based on the confidence vector, physical distance, and phase coupling relationship, and fuses local and global features through a sparse gated residual graph attention layer and a multi-layer LSTM model to achieve high-precision cross-node fault prediction. This method effectively reduces the pressure of data backhaul and improves the real-time and system robustness of anomaly detection.

[0006] To solve the above technical problems, the present invention provides an electric energy meter self-detection and fault prediction method based on edge computing, which includes:

[0007] Step S1: The master cloud platform sends a self-test model package that matches the specifications of the electric energy meter to each edge node installed in the electric energy meter concentrator; the self-test model package includes: an encrypted handshake file and an inference engine;

[0008] Step S2: The edge node completes the communication connection with the master cloud platform through an encrypted handshake file, then calls the inference engine to perform multi-scale empirical mode decomposition on the multiple electric energy meter operation data obtained by real-time sampling to obtain a multi-dimensional weight mask, thereby completing local rapid self-check, confirming the multi-dimensional weight mask as a confidence vector and outputting it;

[0009] Step S3: After the master cloud platform receives the confidence vectors from all edge nodes, it dynamically generates an adjacency graph for each electricity meter based on the physical distance and phase coupling of the electricity meter, and forms multiple different sub-topologies through Monte Carlo pruning to improve the robustness to network fluctuations; then, a sparse gated residual graph attention layer is introduced on each sub-topology to perform gated shielding on low-correlation edges and retain the original features using residual paths, thereby extracting high-order node representations that integrate local and global contexts; each edge node inputs the obtained high-order node representation into the local LSTM to capture its own short-term fluctuations and long-term trends, and then uploads the output vector to the master cloud platform, which uses the master cloud platform LSTM to perform cross-node timing modeling and generate global fault predictions.

[0010] Furthermore, step S1 includes: the master station cloud platform registers the self-test model package with a number, and creates a task record for each edge node in the master station cloud platform task list; the master station cloud platform initiates a connection request to the edge node installed in the electricity meter concentrator, and the edge node accepts the connection request and returns the reception readiness information; the master station cloud platform sends the encrypted handshake file to the edge node, and the edge node immediately uses the locally stored master station public key to perform integrity verification on the encrypted handshake file after receiving it, and returns the verification result; when the master station cloud platform receives the verification success information returned by the edge node, the master station cloud platform starts to send the inference engine blocks to the edge node; after all the blocks are sent, the master station cloud platform sends a transmission end identifier to the edge node; after receiving all the inference engine blocks and completing the reorganization, the edge node performs integrity verification on the inference engine; when the verification passes, the edge node merges the encrypted handshake file with the inference engine to form a complete local copy of the self-test model package, and returns confirmation information to the master station cloud platform.

[0011] Furthermore, the process of the edge node reorganizing the inference engine blocks includes: after receiving each inference engine block, writing the inference engine block into the local temporary buffer according to its sequential number, and generating a temporary file index table entry for each inference engine block; immediately performing a single block integrity check on the inference engine block just written; if the check fails, sending a retransmission request to the main station cloud platform through the existing connection until the inference engine block check is successful; when it is detected that the number of inference engine blocks in the temporary file index table is exactly the same as the total number marked by the main station cloud platform in the encryption handshake file, entering the overall reorganization process; if the number is inconsistent, continue to wait for the arrival of the remaining inference engine blocks; sort the temporary file index table according to the sequential number of the inference engine blocks; after the sorting is completed, the edge node reads the contents of each inference engine block in turn and writes them into the reorganization buffer, and performs an overall integrity check on the inference engine in the reorganization buffer; if the overall integrity check fails, the edge node deletes the reorganization buffer; if the overall integrity check succeeds, the inference engine that passes the overall integrity check is moved from the reorganization buffer to the local storage partition.

[0012] Furthermore, in step S2, the process of calling the inference engine to perform multi-scale empirical mode decomposition on the multiple electric energy meter operation data obtained by real-time sampling includes: the edge node calls the inference engine to write the multiple electric energy meter operation data obtained by real-time sampling into the local ring buffer in the order of arrival; the analysis window is divided according to the fixed time span in the ring buffer, and a sequential index is established for each analysis window. The inference engine scans the current analysis window in turn, marks all local maximum points and local minimum points, connects the local maximum points and local minimum points through the interpolation curve, and obtains the upper envelope curve and the lower envelope curve. According to the alignment of the upper envelope curve and the lower envelope curve, the inference engine scans the current analysis window in turn, marks all local maximum points and local minimum points, and connects the local maximum points and local minimum points through the interpolation curve to obtain the upper envelope curve and the lower envelope curve. The sampling points should be selected and the point-by-point mean curve of the two should be calculated to provide a reference baseline for removing local trends; the mean curve is subtracted point by point from the original electricity meter operating data of the current analysis window to generate modal components; the modal components are written into the modal result list, and the modal components are subtracted from the original electricity meter operating data of the current analysis window to obtain a new residual sequence; if the residual sequence still contains decomposable information, the inference engine returns to sub-step S23 to start the next level of decomposition; if the residual sequence is monotonic, the multi-scale empirical mode decomposition of the current analysis window is terminated; all modal components and the final residual sequence obtained in the current analysis window are combined into a multidimensional feature tensor in the order of generation.

[0013] Furthermore, in step S2, the process of completing local rapid self-check and outputting the confidence vector includes: searching the historical baseline matching template in the historical baseline library, and comparing it with the multidimensional feature tensor by cosine similarity; confirming the historical baseline matching template with the highest cosine similarity as the best matching template; and generating a multidimensional weight mask as the confidence vector based on the degree of deviation between the best matching template and the multidimensional feature tensor in each dimension.

[0014] Furthermore, in step S3, the master station cloud platform retrieves the physical location information and phase connection information of each electric energy meter from its pre-stored electric energy meter equipment list one by one, establishes an initial node with each electric energy meter as the center, and assigns an eigenvalue vector to the initial node based on the confidence vector of each electric energy meter; the initial node set is represented as an electric energy meter topology basic graph, in which each node exists independently and has no edge connection; the master station cloud platform performs neighbor node expansion on each electric energy meter node in the electric energy meter topology basic graph one by one, including: taking the current node to be expanded as the starting node, calculating the physical distance between the current node and all other nodes, and then performing the neighbor node expansion. The physical space distance is calculated to screen out all candidate neighbor nodes whose physical distance is less than the physical proximity threshold preset by the master station cloud platform; the grid phase connection information of the candidate neighbor nodes is compared with the grid phase connection information of the current node one by one to determine whether there is a phase coupling relationship between each candidate neighbor node and the current node, including: if the candidate neighbor node and the current node are located in the same grid phase branch or there is a clear electrical connection path between different grid phase branches, then it is considered that there is a phase coupling relationship between the candidate neighbor node and the current node; otherwise, it is considered that there is no phase coupling relationship and the candidate neighbor node is discarded.

[0015] Furthermore, in step S3, the master station cloud platform further calculates the confidence vector similarity between the candidate neighbor node and the current node for the candidate neighbor node that meets both the physical proximity condition and the phase coupling relationship; if the confidence vector similarity is higher than the pre-defined confidence vector similarity threshold, the master station cloud platform confirms that the candidate neighbor node is a valid neighbor node, connects it to the current node, and updates the current node adjacency graph; otherwise, no node connection is established; until all nodes in the electricity meter topology basic graph complete the neighbor node expansion and obtain a complete adjacency graph set; the master station cloud platform performs a Monte Carlo clipping process on the adjacency graph set; the specific Monte Carlo clipping process is: the master station cloud platform randomly selects a starting node in the adjacency graph as the starting node of the random traversal; starting from the starting node, the traversal path is gradually expanded in a random manner. Each time the expansion is performed, the neighbor node of the current node is randomly selected and expanded to the neighbor node; after each expansion, check whether the traversal path length and the number of nodes reach the pre-set traversal stop criterion. If the stop criterion is met, the traversal is stopped immediately to generate the current sub-topology; if the stop criterion is not met, the expansion continues.

[0016] Furthermore, in step S3, the main station cloud platform is extracted to instantiate a sparse gated residual graph attention layer for each sub-topology that has been generated, and all nodes in the sub-topology and their current feature vectors are used as the input node set of the sparse gated residual graph attention layer; the sparse gated residual graph attention layer traverses each connection edge in the current sub-topology, calculates the edge correlation based on the feature vectors of the nodes connected at both ends in the input node set, and performs descending order on all connection edges according to the numerical value of the edge correlation to generate an edge correlation sorted list; performs low correlation screening on the edge correlation sorted list to identify all connection edges with a correlation lower than a preset low correlation threshold, and adds these connection edges to the list. The edges are marked as low-correlation edges, and the corresponding gated shielding masks are generated inside the sparse gated residual graph attention layer; the sparse gated residual graph attention layer activates the gated shielding mechanism for the low-correlation edges according to the gated shielding mask, blocking the weight update and feature propagation path of the low-correlation edges in this round of information transmission, and applies the graph attention mechanism to the unshielded high-correlation edges, distributes attention weights between the high-correlation edges, and performs a feature aggregation based on adjacency to obtain the intermediate node representation that integrates local context information; at the same time, the sparse gated residual graph attention layer establishes a residual path for each node, bypassing the graph attention mechanism and passing the original input feature vector directly to the next processing stage.

[0017] Furthermore, in step 3, at each node, the intermediate node representation and the feature vector retained by the residual path are paired and superimposed element-by-element, and the superposition results are normalized to obtain the first-stage fusion features; after the normalization is completed, the sparse gated residual graph attention layer stores the first-stage fusion features into a temporary feature buffer; the sparse gated residual graph attention layer performs a global context diffusion process based on the first-stage fusion features: taking each node of the current sub-topology as the diffusion starting point, a diffusion-merging cycle is performed alternately between the two adjacent layers of nodes; in each diffusion process, the sparse gated residual graph attention layer reuses the gated shielding mechanism to ensure that low-correlation edges are continuously shielded on the global diffusion path and the residual path is kept connected; in each merging process, the sparse gated residual graph attention layer again superimposes and normalizes the node features obtained by diffusion with the accumulated features in the residual path, and outputs the final node feature vector that fuses local context information and global context information as the high-order node representation of the sub-topology.

[0018] The electric energy meter self-inspection and fault prediction method based on edge computing of the present invention has the following beneficial effects: The electric energy meter self-inspection and fault prediction method based on edge computing of the present invention fully utilizes the advantages of edge nodes being close to the sampling source, fast real-time response, and computing load sharing, and realizes local rapid judgment of the operating status of the electric energy meter and multi-node collaborative fault prediction, effectively making up for the problems of data backhaul bottleneck, excessive computing pressure of the central node, and delayed abnormal detection response in the prior art. In the present invention, the master station cloud platform enables the edge node to have the ability to independently perform modal analysis and state modeling by issuing a self-inspection model package that matches the specifications of the electric energy meter. By performing multi-scale empirical mode decomposition locally at the edge node and outputting a confidence vector, it is possible to quickly complete a preliminary judgment on the abnormal operation of the electric energy meter without relying on real-time calculations of the central server, significantly improving the timeliness and robustness of the detection. Furthermore, the master station cloud platform integrates the self-test results of multiple edge nodes to construct an adjacency graph linking the physical space of the electricity meter to the electrical phase. It also introduces a sparse gated residual graph attention mechanism to eliminate interference between low-correlation nodes while retaining key node features. This effectively improves the overall system's perception of local anomalies, regional fluctuations, or potential fault trends. This invention achieves layer-by-layer fusion and dynamic modeling of multi-source heterogeneous information throughout the entire process, ultimately generating predictive and context-aware fault warning results using local and global LSTM modeling architectures. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are merely embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on the provided drawings without paying any creative work.

[0020] Figure 1 A schematic diagram of a method flow for an electric energy meter self-checking and fault prediction method based on edge computing provided by an embodiment of the present invention;

[0021] Figure 2 Schematic diagram of multi-scale empirical mode decomposition;

[0022] Figure 3 Schematic diagram of the adjacency graph generation and Monte Carlo pruning process;

[0023] Figure 4 Flowchart of the sparse gated residual map attention layer processing;

[0024] Figure 5 This is a comparison chart of the overall system performance evaluation and fault prediction accuracy. DETAILED DESCRIPTION

[0025] The method of the present invention will be further described in detail below with reference to the accompanying drawings and embodiments of the present invention.

[0026] Example 1, reference Figure 1 : An electric energy meter self-detection and fault prediction method based on edge computing, which includes:

[0027] Step S1: The master cloud platform sends a self-test model package that matches the specifications of the electric energy meter to each edge node installed in the electric energy meter concentrator; the self-test model package includes: an encrypted handshake file and an inference engine;

[0028] The present invention relies on the dual-layer collaborative architecture of the master station cloud platform and edge nodes to decouple the collection, analysis, and decision-making chains of the electricity meter operation data into the smallest closed loop according to the function, and uses the self-check model package as the only verifiable software unit to quickly complete the loading and activation on the edge side, thereby reducing the outflow of original data at the source and reducing the calculation concentration on the master station side. The core principles run through three logical main lines: the main line of safe and controllable model distribution, the main line of feature extraction for non-stationary sequences, and the main line of multi-level reasoning that integrates local and global dependencies. The following text follows the writing habits of the embodiments and continuously explains the specific implementation mechanism of each main line in steps S1 to S3 from a system perspective.

[0029] In step S1, the master cloud platform first combines the encrypted handshake file and the inference engine to form a self-checking model package. The encrypted handshake file performs identity verification and data integrity verification. It uses the master public key pre-installed on the edge node as a root of trust and uses the integrity summary field to encapsulate the inference engine's block count and sequence mapping. During the connection establishment phase, the edge node parses the encrypted handshake file to declare its own legitimacy and provide a reference table for subsequent block transmission. Transmission utilizes a block-level retransmission protocol: Each received block is immediately subjected to a single block integrity check; failures trigger a retransmission. When the block count in the temporary file index table reaches the declared total, full reassembly begins. At this point, a digest is simply calculated for the byte stream in the reassembly buffer and compared with the overall digest provided by the encrypted handshake file. The purpose of block transmission and two-level verification is not simply to ensure reliable downloading, but rather to pre-place the verification logic into the micro-slot before the edge node is interrupted. This ensures that the inference engine remains in a partially executable state under any abnormal link conditions, preventing unknown code fragments from residing within the meter concentrator. Once a local copy of the complete self-check model package is generated and sent back for confirmation, the master cloud platform will mark the task closed-loop completed.

[0030] Step S2: The edge node completes the communication connection with the master cloud platform through an encrypted handshake file, then calls the inference engine to perform multi-scale empirical mode decomposition on the multiple electric energy meter operation data obtained by real-time sampling to obtain a multi-dimensional weight mask, thereby completing local rapid self-check, confirming the multi-dimensional weight mask as a confidence vector and outputting it;

[0031] In step S2, the edge node invokes the inference engine to initiate real-time analysis. Electricity meter operating data is a non-stationary, narrowband power factor sequence with periodic jumps. Direct single-scale operations in the time or frequency domain can easily mask small drifts. Therefore, the inference engine employs multi-scale empirical mode decomposition (EMD) to decompose the original sequence into adaptive intrinsic mode functions and residuals. This series of operations, including upper and lower envelope curves at local maxima and minima, and point-by-point mean curves, is equivalent to searching for implicit vibration centers without a priori filter kernels. The energy distribution from high to low frequencies is then iteratively stripped. Each modal component thus obtained corresponds to a time-domain image of a different operating mechanism (such as load activation, metering error accumulation, and temperature drift), while the final residual characterizes the baseline trend that slowly evolves over time. All modal components and residuals are stacked to generate a multidimensional feature tensor. Cosine similarity comparison is not a simple similarity search, but rather uses directional vector comparison to ensure that the template used by the edge node relies solely on scale distribution consistency rather than absolute amplitude. When generating a multidimensional weighted mask in this way, deviations are directly mapped to low weights across the dimensions, achieving local amplification of transient anomalies. This mask is normalized and converted into a confidence vector. Because the generation process is completely closed on the edge, the main cloud platform only receives the vectors and not the original data, ensuring a balanced balance between privacy and bandwidth.

[0032] Step S3: After the master cloud platform receives the confidence vectors from all edge nodes, it dynamically generates an adjacency graph for each electricity meter based on the physical distance and phase coupling of the electricity meter, and forms multiple different sub-topologies through Monte Carlo pruning to improve the robustness to network fluctuations; then, a sparse gated residual graph attention layer is introduced on each sub-topology to perform gated shielding on low-correlation edges and retain the original features using residual paths, thereby extracting high-order node representations that integrate local and global contexts; each edge node inputs the obtained high-order node representation into the local LSTM to capture its own short-term fluctuations and long-term trends, and then uploads the output vector to the master cloud platform, which uses the master cloud platform LSTM to perform cross-node timing modeling and generate global fault predictions.

[0033] After step S3 is initiated, the master cloud platform possesses confidence vectors from all edge nodes. First, the geographic coordinates and phase connection metadata of the device list are retrieved. An adjacency graph node is instantiated for each electricity meter, and edges are expanded based on three criteria: physical distance less than a threshold, phase coupling, and vector similarity greater than a threshold. Connections formed by these three criteria can be interpreted as potentially being jointly affected by the same local power supply or load disturbance. To improve robustness to sudden fluctuations such as line switching, communication noise, and node offline, Monte Carlo pruning is used to generate multiple differential subtopologies on the adjacency graph set: starting points are randomly selected, paths are randomly expanded, and traversal stops according to a stopping criterion, resulting in structural samples containing random redundancy. Each subtopology instantiates a sparse gated residual graph attention layer. This layer first traverses and calculates edge correlation. Edges below a low correlation threshold are written into a gated mask, ensuring their weights are always zero in information propagation within this layer. Furthermore, a residual path is retained for each node, allowing the original features to be directly passed to the next stage. When highly correlated edges are assigned learnable weights within the attention mechanism, nodes exchange information only with neighbors with strong electrical correlations, reducing feature dilution. The residual path prevents gradient vanishing due to excessive masking. The intra-layer diffusion-merge loop further diffuses locally aggregated features to more distant nodes within a bounded step size, while continuously reusing gated masking to ensure that low-correlation edges remain disconnected. The output high-level node representation at the end of the loop fuses multiple levels of context while preserving the original details.

[0034] Edges in subtopology Edge correlation for:

[0035] ;

[0036] in, is the edge correlation, the sparse gated residual map attention layer is sorted by, dimension 1; is the phase coupling flag; it is 1 if the two-node grids are phase coupled, otherwise it is 0 (dimension 1); For nodes 、 Physical distance (m); The physical proximity threshold (m) preset by the main station cloud platform; For nodes The current feature vector when the current sub-topology enters the sparse gated residual graph attention layer (generated by the multi-dimensional feature tensor → confidence vector → adjacency graph aggregation → first stage fusion feature process, with the same dimension as the sampling power); is the cosine similarity based on the feature vector (dimension 1).

[0037] After returning to each edge node, the high-order node representation enters the local LSTM. The local LSTM executes in a rolling time window of minutes or seconds, using short-term gating to capture sudden drift in the electricity meter itself and long-term memory to store seasonal trends in the accumulated load. The resulting output vector represents a summary of the single-node prediction and is then sent to the master cloud platform. The master cloud platform LSTM collects all node output vectors and performs parallel modeling on time widths of hours or longer. Using shared latent states, it extracts cross-node resonance patterns, such as consistent fluctuations across multiple meters caused by abnormal distribution transformers in a certain section. Because the input vector is already a time series projection of the high-order node representation, the master station no longer requires large-scale graph computation. Cross-node time series modeling can be performed directly in the LSTM, ultimately generating a global fault prediction. Once the prediction result reaches the dispatch warning threshold, the cloud platform can issue maintenance instructions, achieving a closed-loop proactive maintenance process driven by predictions.

[0038] In summary, the core principles of the present invention are reflected in the following inherent coordination: First, the self-checking model package couples code security and network availability through block transmission and double integrity verification; Second, the multi-scale empirical mode decomposition automatically extracts the scale structure of non-stationary sequences in a purely data-driven manner, and outputs measurable credibility; Third, the adjacency graph integrates the physical-phase-vector three-dimensional criteria to establish a highly interpretable multi-graph set, and uses Monte Carlo cropping to randomize the sample space; Fourth, the sparse gated residual graph attention layer relies on gated masking and residual paths to maintain information sparsity while avoiding feature loss; Fifth, the hierarchical LSTM progressively models along the edge node-master station cloud platform direction to achieve multi-scale time series reasoning from local minute-level diagnosis to global hour-level prediction.

[0039] Furthermore, step S1 takes the construction of a trust chain between the main station cloud platform and the edge node as its core principle. By establishing the encrypted handshake file as the only trusted root and treating the inference engine blocks as the payload to be verified, a double-layer integrity verification closed loop combining a priori verification and a posteriori reconstruction is formed. When the main station cloud platform registers the number of the self-check model package, it simultaneously writes the package number and version number into the task list, essentially generating a traceable digital fingerprint on the central side. This fingerprint will subsequently run through the entire process from connection request, block transmission, reassembly verification to local landing. The essence of the connection request stage is to use an active handshake to introduce a one-way, tamper-proof identity authentication for the data channel. That is, the edge node must first parse the encrypted handshake file and complete the integrity verification using the locally stored main station public key before entering the payload receiving mode. The main station public key acts as an offline fixed trust anchor here, so that any forged handshake or man-in-the-middle hijacking will be rejected immediately.

[0040] After entering the inference engine and being sent in blocks, the system breaks the large model into sequentially numbered, discrete blocks, each carrying a local digest. This reduces the cost of single retransmissions and shifts verification granularity to the block level, ensuring that network jitter or link errors only affect individual blocks without contaminating the entire system. A temporary file index table built locally by the edge node records the mapping between verified blocks and block numbers, effectively creating a real-time progress ledger at the edge. Reassembly buffers are only triggered when the number of blocks in the index table matches the total number stated in the encrypted handshake file, preventing hidden logical gaps caused by missing blocks. Overall integrity is verified through a full-packet digest comparison to ensure byte-level inconsistencies after block-level splicing, completing the post-verification verification. If successful, the edge node merges the encrypted handshake file with the inference engine and writes it to a persistent partition to create a local copy of the self-checking model package. This step solidifies the trust chain: the local copy of the self-checking model package becomes the sole source file for subsequent multi-scale empirical mode decomposition runs, and any future updates must undergo the same two-layer verification process. At the same time, the edge node transmits the confirmation information back to the main station cloud platform, and the dispatched task record in the task list is synchronously updated to completed, recording the timestamp and verification results, ensuring that the center can hold the model accountable and perform version rollbacks for the entire life cycle of each dispatch. In summary, step S1 embeds the prior handshake verification, block-level error location, and a posteriori reconstruction verification into the same state machine, so that the encrypted handshake file and the inference engine block can be safely implemented without blind spots under network edge conditions. This fundamentally ensures that the inference engine relied on by subsequent edge computing links is trustworthy at the source, complete in content, and controllable in version, and provides a consistent inference environment for the unified timing logic of cross-node fault prediction.

[0041] Furthermore, in an edge computing-based electricity meter self-test and fault prediction method, the underlying mechanism by which edge nodes reassemble inference engine blocks is to break down large executable payloads into independently verifiable, fine-grained segments. A two-level verification strategy is then employed to ensure byte-level consistency and version-level traceability within a constrained link environment. When an edge node receives the first inference engine block, it writes the data to a local temporary buffer based on its sequence number and creates an entry in the temporary file index table to identify the block sequence and verification status. Upon completion of the write, the device immediately performs a single-block integrity check, using a local digest of the block header to determine whether the bitstream has been permuted, truncated, or replayed. If the check fails, the edge node sends a retransmission request to the master cloud platform via the existing connection and continues retrying within the same session until the block is verified. Because each block is independently verified, the system can detect and correct random bit errors within a very short loop, isolating errors to a single block without contaminating other verified blocks. As more inference engine blocks arrive, the temporary file index table dynamically accumulates the number of entries, and the edge node continuously compares the entry count with the total number of annotations in the encryption handshake file. When the condition that the two are completely consistent is met, it means that all blocks have been collected in theory, and the overall reorganization process begins.

[0042] If the count is still insufficient, continue to wait for the remaining blocks to arrive and maintain real-time verification of the arrived blocks. After entering the overall reassembly process, the system sorts the temporary file index table according to the sequential numbering of the inference engine blocks to ensure that the subsequent splicing order is consistent with the original sequence; after the sorting is completed, the edge node reads the contents of each block in turn and writes them into the reassembly buffer. After the buffer constructs a complete byte stream, it immediately performs an overall integrity check on the inference engine in the reassembly buffer. This check is different from the previous single-block integrity check. It uses the overall summary provided by the encrypted handshake file. It verifies whether there are logical gaps, repeated insertions, or sequence dislocations after cross-block splicing, thereby making a one-to-one correspondence between the reassembled data and the original release state of the main station. If the overall integrity check fails, the edge node determines that the current reassembly is invalid, immediately deletes the reassembly buffer to eliminate potential pseudocode residues, and returns to the receiving state to wait for the master station to re-trigger the block retransmission. If the overall integrity check succeeds, the system confirms that it has obtained the inference engine consistent with the master station cloud platform, and then moves it from the reassembly buffer to the local storage partition and physically merges it with the previously saved encrypted handshake file, so that the two form an executable and verifiable local copy of the self-test model package under the same file system node. At this time, the edge node sends a confirmation message to the master station cloud platform, reporting the success of the reassembly and the verification, so that the master station can update the task status. The entire process provides block-oriented instant error correction through single-block integrity verification, and achieves end-to-end eventual consistency through overall integrity verification. It uses a temporary file index table to maintain real-time to block mapping, and uses a reorganization buffer to complete orderly splicing. It is supplemented by failure immediate purge logic to ensure that no junk files remain. From the underlying technology, it eliminates multiple risks such as link noise, block loss, replay attacks, and sequence dislocation, and provides a complete and version-correct runtime environment for the subsequent multi-scale empirical mode decomposition that relies on the inference engine, thereby building a self-sourced and trusted model release and implementation channel in the entire edge computing-based electricity meter self-inspection and fault prediction system.

[0043] Furthermore, in the present invention, the multi-scale empirical mode decomposition is designed to run serially from a ring buffer to an analysis window and then decompose layer by layer because the operating data of the electric energy meter has significant non-stationarity and cross-scale superposition characteristics, and the traditional fixed basis function method cannot simultaneously take into account both instantaneous disturbance capture and trend extraction. The edge node first writes the real-time sampled data into the ring buffer in the order of arrival, so that the sequence forms a linear address space connected end to end in the physical memory, thereby ensuring that the pointer only needs a single atomic update to complete the loop during continuous writing, avoiding the jitter introduced by lock contention. The analysis window is then divided according to a fixed time span, and a sequential index is established for each analysis window; this index not only records the relative position of the window in the total sequence, but also provides a synchronization benchmark for the inference engine, so that the subsequent decomposition layers are aligned with a unified sampling step size. The inference engine scans the current analysis window one by one, marking local maxima and minima in real time. This step actually extracts the extreme value skeleton from the original time domain trajectory; then, the local maxima and minima are connected through interpolation curves to obtain the upper envelope curve and the lower envelope curve, and the point-by-point mean curve is calculated using the values ​​of the two at the same sampling point. This point-by-point mean curve is essentially a local reference baseline generated spontaneously by the data, which is used to offset the trend drift within the window. The inference engine subtracts this baseline from the original data point by point, and the difference is the first-level modal component. Because the modal component satisfies the characteristics of local symmetry and the difference of one in the number of extreme values, it naturally corresponds to a specific oscillation mode or short-period disturbance under the operating state of the electricity meter.

[0044] When this modal component is written to the modal result list, it is simultaneously subtracted from the original data to produce a new residual sequence. The inference engine immediately rechecks the extreme value distribution on the residual sequence. If the residual sequence still contains decomposable information, it returns to the extreme value marking step described above and recursively generates the next layer of modal components. The signal's underlying trend layer is considered fully preserved until the residual sequence appears monotonic or contains only a few extreme endpoints. Throughout this process, each extreme value marking and envelope interpolation is performed within the analysis window, ensuring that a layer-by-layer detrended interpretable expression is obtained without any prior filters. Ultimately, all modal components generated in the current analysis window and the final residual sequence are combined into a multidimensional feature tensor in the order of generation. Its channel dimension stores information from high frequency to low frequency, while the sample dimension maintains a one-to-one correspondence with the original sampling points. This multidimensional feature tensor is then converted into a multidimensional weight mask and converted into a confidence vector in the next step. Through this fully data-driven and layer-by-layer adaptive decomposition mechanism, edge nodes can simultaneously achieve high sensitivity to instantaneous fluctuations and low-distortion representation of baseline trends under lightweight hardware conditions. This lays a foundation for the subsequent construction of an adjacency graph on the main station cloud platform, the introduction of a sparse gated residual graph attention layer, and the execution of cross-node LSTM modeling, with distinct scales, phase alignment, and complete information.

[0045] Furthermore, on the edge node side of the present invention, the multidimensional feature tensor obtained by real-time decomposition is mapped to the operating paradigm space described by the historical baseline library, and the morphological consistency is characterized by comparing the vector direction rather than the amplitude, and then the overall similarity is refined into the scale-by-scale deviation sensitivity. When the multidimensional feature tensor is generated, the inference engine first starts the index retrieval process, traverses all the historical baseline matching templates in the historical baseline library, multiplies and accumulates each historical baseline matching template with the current multidimensional feature tensor element by element, and calculates their respective norms at the same time. The quotient of the two is the cosine similarity, and a set of similarity sequences with the same length as the number of templates is obtained. The historical baseline matching template corresponding to the maximum value of the sequence is confirmed as the best matching template. At this time, the multidimensional feature tensor and the best matching template are in the same feature space coordinate system, and the direction is close but the amplitude difference records the scale-by-scale deviation of the current electricity meter operating state from the ideal baseline. The inference engine then calculates the difference between the best matching template and the multidimensional feature tensor in each dimension and maps this difference to a weight range of [0, 1]. Smaller differences indicate a healthy dimension, and the weight is closer to 1; larger differences indicate anomalies, and the weight decays proportionally. The weights of all dimensions are concatenated to form a multidimensional weight mask, which is directly output as a confidence vector. The numerical distribution of the confidence vector, from high to low, not only provides instantaneous self-check conclusions but also provides clues to locate anomalies at various scales. Furthermore, because cosine similarity is naturally insensitive to amplitude scaling, the entire matching process can be completed rapidly at the edge node without pre-normalizing the original features, significantly reducing computational overhead and ensuring the model's robustness to meter load fluctuations.

[0046] Furthermore, on the master station cloud platform side of the present invention, the construction logic of the basic topology graph of the electric energy meter is based on the propagation mechanism of fault energy in the distribution network as the core principle, and the three complementary information of physical proximity, electrical phase coupling and confidence vector are integrated into the same node expansion framework, thereby grafting the scattered single-meter self-test results onto a structured graph model that can be used for global reasoning. When step S3 is started, the master station cloud platform first retrieves the physical location information and phase connection information of each electric energy meter from the equipment list, maps these metadata to the coordinate system and phase domain, and establishes an initial node with each electric energy meter as the center; then, based on the confidence vector corresponding to each electric energy meter, the vector is written into the node attribute as the node eigenvalue vector, and the basic topology graph of the electric energy meter containing only nodes and no edge connections is obtained. The edgeless state of this graph means that only the health weighting has been completed, and the possible mutual influence between the electric energy meters has not yet been modeled; therefore, the master station cloud platform performs a neighbor node expansion operation on each electric energy meter node in the graph. The expansion first constrains the search range from a physical space perspective: with the current node to be expanded as the center of the circle, the physical space distance between it and all other nodes is calculated, and all candidate neighbor nodes whose physical distance is less than the physical proximity threshold are screened out. The theoretical basis for this is that the energy transmitted in space by faults or load disturbances on the distribution side often exhibits a power-law distribution that decays with distance. Only electricity meters that are close enough are likely to be in the same disturbance influence domain.

[0047] After obtaining candidate neighbor nodes, the master station cloud platform uses the grid phase connection information to perform electrical consistency filtering, comparing the grid phase connection information of the candidate neighbor nodes with that of the current node one by one. If the two nodes are located on the same grid phase branch, or if they are located on different phase branches but have a clear electrical connection path, a phase coupling relationship can be determined between them, and the candidate neighbor node is retained. Otherwise, the phase coupling relationship is considered to be absent and the candidate neighbor node is discarded. The core principle of phase coupling filtering is that the phase homogeneity of the voltage and current waveforms of the electricity meter is the electrical prerequisite for fault linkage propagation. Only node combinations that meet the phase coupling relationship can have their operating states synchronously offset within a short time scale. This determination can prevent physically close but electrically isolated nodes from being mistaken for potential fault paths. Through the dual constraints of physical distance screening and phase coupling comparison, the master station cloud platform determines a set of valid neighbors with spatial proximity and electrical coupling for the current node, and adds edge connections with these neighbors on the basic topology map of the electricity meter. This lays the foundation for the subsequent introduction of confidence vector similarity thresholds, execution of Monte Carlo clipping and sparse gated residual graph attention layers that conform to physical reality and electrical laws.

[0048] Furthermore, in the dynamic mapping process of step S3, the master station cloud platform uses hierarchical screening - adaptive section sampling - probabilistic resampling as the core principle to fuse the initial physical topology and real-time health information into a set of adjacency graphs that can be parsed by the subsequent graph attention mechanism; first, after the system completes the double inspection of the physical proximity conditions and phase coupling relationship in the basic graph of the electric energy meter topology, it takes the confidence vectors of each group of candidate neighbor nodes and the current node and calculates the cosine metric, and defines the resulting scalar as the degree of similarity of the confidence vectors, which reflects the multi-scale similarity of the two nodes in the same diagnostic cycle. Consistency of deviation direction; if the confidence vector similarity is higher than the pre-defined confidence vector similarity threshold, it is determined that the two are synchronized in health state evolution. The master cloud platform immediately promotes the candidate neighbor node to a valid neighbor node, and writes an undirected edge connection in the graph structure. The edge attribute stores a ternary label: physical distance, phase coupling mark and confidence vector similarity, which is used to participate in the edge correlation calculation in the subsequent sparse gated residual graph attention layer; if the similarity does not reach the threshold, the edge construction is abandoned to prevent irrelevant state noise from entering the feature propagation path.

[0049] This process, run sequentially for all nodes, forms an adjacency graph set whose connection density adapts to the threshold. Due to uncontrollable factors on the actual distribution side, such as message loss, node offline, and sudden load switching, a single adjacency graph cannot account for both steady-state information and transient jitter. Therefore, this paper introduces a Monte Carlo pruning mechanism on the adjacency graph set to perform probabilistic resampling of the structure. The specific approach is: the main station cloud platform uses uniform random distribution to select a starting node as the starting node of random traversal in any adjacency graph, pushes the starting node into the traversal stack and marks it as visited, and then extracts the next hop with linear probability from the neighbor list of the top node of the stack, pushes the extraction result into the stack and marks a traversal edge in the graph; the algorithm maintains two counters, which record the traversal path length and the number of visited nodes respectively. Whenever an edge is pushed into the stack, the count is incremented and compared with the traversal stopping criterion. The traversal stopping criterion is jointly defined by the maximum path length threshold and the maximum number of nodes threshold. When any of the thresholds is reached, early stopping is triggered; during early stopping, the system extracts all nodes and their edge connections from the traversal stack and the set of visited nodes, constructs the current sub-topology and writes it into the sub-topology pool; if the threshold is not reached, random expansion continues with the latest top node until the criterion is met. This random traversal introduces randomness in the selection of starting nodes, neighbor extraction, and path termination, so that each clipping cuts off a sub-path with obvious structural differences from the global adjacency graph and expands a sub-topology from it; by repeatedly performing Monte Carlo clipping on the original adjacency graph set, the main station cloud platform obtains multiple sub-topologies. These sub-topologies statistically maintain the node degree distribution and clustering coefficient characteristics of the original graph, but show diversity in the local edge distribution, which is equivalent to bootstrap sampling in the topological space, thereby providing redundant perspectives for the subsequent sparse gated residual graph attention layer: if an edge appears repeatedly in most sub-topologies, its edge correlation will be significantly amplified during the training phase, reflecting as a core path; on the contrary, edges that only appear occasionally will be weakened due to gating shielding, so that the high-order node representation has endogenous robustness to network perturbations and observation gaps, and ensures that global fault prediction will not be amplified by single topology errors during cross-node time series modeling.

[0050] Furthermore, after the main station cloud platform completes the Monte Carlo pruning, each sub-topology will be immediately injected with a sparse gated residual graph attention layer. The core principle of this layer is to quantify the connection strength through edge correlation, then actively sparse the low-value edges with a gated shielding mask, and finally use the residual path to retain the input features to suppress information loss. First, the system integrates all the nodes in the sub-topology and their current feature vectors into the input node set of the sparse gated residual graph attention layer; then, the layer traverses each connecting edge in the sub-topology, takes the feature vectors of the nodes at both ends of the edge, and performs vector similarity projection after linear mapping to obtain the edge correlation. This metric directly reflects the influence of the two nodes on each other in the current feature space. The edge correlation of all connecting edges is collected into the edge correlation sorting list and sorted in descending order by value, thereby establishing a global priority.

[0051] After sorting, the layer performs business-driven low-correlation filtering: all connected edges with an edge correlation below a low-correlation threshold are marked as low-correlation edges, and a corresponding gated mask is immediately generated within the sparse gated residual graph attention layer. The gated mask is a sparse binary matrix that is directly applied to the adjacency matrix during the subsequent forward propagation, setting all weight updates and feature propagation paths of low-correlation edges in this round of information transfer to zero. For unmasked high-correlation edges, the layer initiates a graph attention mechanism: first, the connected node features are normalized using the edge correlation as the pre-attention weight. Adjacency-based feature aggregation is then performed on the normalized attention weights. Each node then sums the features of its neighboring high-correlation nodes according to their weights, generating an intermediate node representation that incorporates local context information. Simultaneously, the sparse gated residual graph attention layer establishes a residual path for each node, passing the original input feature vector directly to the next processing stage, bypassing the graph attention mechanism. The residual pathway and attention aggregation output are element-wise added and normalized in subsequent stages, preserving fine-grained original information while injecting local context through attention aggregation of highly correlated edges. This mathematically avoids gradient vanishing and over-smoothing, and logically ensures that low-correlation noise is effectively truncated by the gated mask. Ultimately, the intermediate node representation output by this layer inherits the local feature richness of attention aggregation in terms of scale and the original information integrity of the residual pathway in terms of robustness, providing a reliable and sparse feature foundation for the subsequent global context diffusion and high-order node representation.

[0052] Furthermore, after the sparse gated residual graph attention layer completes feature aggregation for highly correlated edges, the intermediate node representations have not yet interacted with the original feature vectors in the residual path. Therefore, the layer first performs element-by-element pairing and superposition of the intermediate node representations and the feature vectors retained by the residual path at each node, synchronously mapping the two information sources to the same feature coordinate system. Immediately after superposition, batch normalization is applied to the result to ensure numerical stability at the same scale across different nodes. The normalized output is the first-stage fused feature. The sparse gated residual graph attention layer writes the first-stage fused features to a temporary feature buffer, providing writable and readable shared memory for the subsequent global context diffusion process.

[0053] The global context diffusion process uses each node in the current sub-topology as the diffusion starting point, and alternately executes a diffusion-merge cycle between nodes in two adjacent layers: the diffusion stage propagates the fused features of the first stage along the graph structure, and the information diffuses one hop in space along the path; the merging stage aggregates the diffused neighbor features back to the starting node, achieving a feature recovery with a radius of two. To prevent low-correlation noise from being repeatedly amplified during cross-layer propagation, the sparse gated residual graph attention layer reuses the gated shielding mechanism in each diffusion process, continuously shielding all low-correlation edges while keeping the residual path connected, so that the original features still maintain the gradient reference after multiple iterations. During each merging process, the node features obtained by diffusion and the accumulated features in the residual path are superimposed and normalized within the layer again to further suppress numerical explosion and maintain information balance. After a preset number of diffusion-merge cycles, the node has absorbed both local context information and global context information across multiple hops. The sparse gated residual graph attention layer uses the merged output as the final node feature vector, which combines local fine patterns and long-range dependency structures. It is defined as the high-order node representation of the sub-topology and is passed to the subsequent time series modeling stage.

[0054] Global failure prediction probability for:

[0055] ;

[0056] in ;

[0057] For the main site cloud platform in the advanced window The global fault prediction (probability, dimension 1) is given later; is the number of edge nodes (dimension 1); is the Sigmoid activation function, which maps similarity to node-level failure probability; For nodes The confidence vector of (dimension 1); For nodes high-order node representation of (output by the sparse gated residual graph attention layer); For nodes in the sub-topology Maintain a set of neighbors with high association connections; is the gated mask element; if the edge If blocked (Dimension 1) is the edge correlation.

[0058] The following is a demonstration of the entire process of the present invention from model issuance to global fault prediction using three electricity meters (nodes 1, 2, and 3) on a single machine.

[0059] The main station cloud platform is generating a self-test model package pkg_id = 0x23A7; version = 0x0001. The encryption handshake file size = 512B. The inference engine size = 12288B. Disassemble into 12 pieces and number them separately .

[0060] Write the end-of-file field .

[0061] 09:00:02 The cloud platform initiates a TCP handshake; the edge node returns READYwin=4096crc_poly=0x1021.

[0062] 09:00:03 The encrypted handshake file is delivered once, and the edge node verifies the SHA-256 with the preset public key. .

[0063] Verification successful → reply ACK_HANDSHAKE_OK.

[0064] 09:00:04–09:00:06 The cloud platform sends 12 blocks in sequence. Block 9 CRC-16 calculated value upon arrival , the node replies NACKblk=8 and retransmits, and the verification is successful.

[0065] 09:00:06 All blocks are stored in the temporary buffer 0x8100:0xB000, with block count 12 = block_total. Immediately reassemble and calculate SHA-256 for 12288B: Consistent with the end of the file → Overall integrity passed. The inference engine is moved to the permanent area 0x40000 and merged with the encryption handshake file into pkg_0x23A7.bin. The response is CONFIRM_OK 0x23A709:00:07.

[0066] Sampling frequency per table .

[0067] Ring buffer base address 0x9000, capacity .

[0068] Analysis window width , current window index .

[0069] Taking node 2 as an example, only the first 12 points are listed:

[0070] ; The extreme value search yielded 46 local maxima and 45 local minima. The upper and lower envelope curves were obtained by B-spline interpolation. Mean curve The first layer of IMF: .Pick time:

[0071] ;

[0072] Residual after iteratively stripping 3 layers of IMF (IMF_1, IMF_2, IMF_3); If there are no extra extreme values, stop. Assemble the four sequences in the order they were generated. Nodes 1 and 3 follow the same process, and we get .

[0073] 300 records have been stored in the historical baseline library -Dimensional template Node 2 calculates each item one by one Maximum value. Dimension-by-dimensional difference Normalized multidimensional weight mask Nodes 1 and 3 get .

[0074] coordinate:

[0075] . Physical proximity threshold All three sides are qualified; three meters are connected to the same branch .

[0076] Calculate confidence cosine .

[0077] The remaining two pairs <0.97 → no edges are added. The basic adjacency graph only has edges Monte Carlo Clipping: Traversal Stop Criterion "Path Length or number of nodes "; The starting point is random 5 times → Because the structure is simple, each sub-topology is .

[0078] Input first stage fusion features .

[0079] Calculate edge affinity:

[0080] .

[0081] Threshold 0.20 → Edge preservation, gated mask . High-order node representation .

[0082] Node 3 separate sub-topology .

[0083] The main cloud platform Enter the hidden dimension LSTM: .

[0084] In this example, the output is directly equivalent to To omit the LSTM internal weights.

[0085] Node failure probability .

[0086] .

[0087] Global failure probability:

[0088] .

[0089] Master cloud platform threshold . 09:00:07.150Judgment The cloud platform writes the log FAL-REDpkg=0x23A7win=2748P=0.980ts=2025-06-18T09:00:07.150-04:00.

[0090] At the same time, the work order "Inspection - Distribution Transformer A03 - Concentrator 1 corresponding to electricity meter 1-2-3" is pushed to the dispatching system.

[0091] Figure 2This paper demonstrates the complete processing flow and technical advantages of the multi-scale empirical mode decomposition (EMD) method of the present invention. The left section shows the input of raw meter operating data, obtained through real-time sampling at edge nodes, and contains information on the changes in various electrical parameters during the meter's actual operation. The center section details the core processing of the MMD method. The raw meter operating data is first written into a circular buffer and then divided into multiple analysis windows with fixed time spans. The inference engine processes each analysis window in turn, marking local maxima and minima to generate upper and lower envelope curves, respectively. The point-by-point mean curve of these two curves is calculated as a reference baseline for removing local trends. By point-by-point subtraction of the mean curve from the raw data, the system generates the first modal component. This modal component is then subtracted from the raw data to obtain a new residual sequence. If the residual sequence still contains decomposable information, the inference engine proceeds to the next level of decomposition until the residual sequence becomes monotonic. The resulting multiple modal components (modal component 1, modal component 2, modal component 3) and the final residual sequence are combined into a multidimensional feature tensor in the order in which they were generated. The right side shows the confidence vector generation process. The system retrieves a historical baseline matching template from the historical baseline library, compares it with the multidimensional feature tensor using cosine similarity, and after determining the best matching template, generates a multidimensional weighted mask based on the degree of deviation as the confidence vector. Comparison results show that traditional detection methods have an accuracy rate of only 75%, a long response time, and a high false alarm rate. However, the method proposed in this paper, through multi-scale empirical mode decomposition and self-matching filtering technology, increases detection accuracy to 92%, achieves real-time response, and significantly reduces the false alarm rate. This demonstrates the technical advantage of multi-scale empirical mode decomposition-based feature extraction and self-matching filtering for rapid local self-detection.

[0092] Figure 3The complete technical process for constructing an energy meter adjacency graph and Monte Carlo pruning on the master cloud platform is described in detail. The upper left panel shows the initial state of the energy meter topology base graph, where each energy meter node (Energy Meter 1 to Energy Meter 5) exists independently and has no edge connections. The master cloud platform retrieves the physical location and phase connection information of each energy meter from a pre-stored energy meter device list, establishes an initial node centered around each energy meter, and assigns an eigenvalue vector to each initial node based on the confidence vector of each energy meter. The upper right panel shows the generated complete adjacency graph. The master cloud platform expands the neighboring nodes of each energy meter node in the energy meter topology base graph one by one. The specific process involves: starting with the current node to be expanded, the platform calculates the physical distance between the current node and all other nodes, selecting candidate neighbor nodes whose physical distance is less than a preset physical proximity threshold. The grid phase connection information of each candidate neighbor node is then compared with the current node to determine whether a phase coupling relationship exists. If the candidate neighbor node and the current node are located in the same grid phase branch or there is a clear electrical connection path between different grid phase branches, then the existence of a phase coupling relationship is confirmed. For candidate neighbor nodes that meet both the physical proximity conditions and the phase coupling relationship, the system further calculates the degree of similarity of the confidence vector between it and the current node. If the similarity is higher than the predefined threshold, it is confirmed as a valid neighbor node and an edge connection is established. The three sub-topologies below show the results of the Monte Carlo pruning process. The master station cloud platform randomly selects the starting node in the adjacency graph as the starting point of the random traversal, and gradually expands the traversal path in a random manner. Each time, the neighbor node of the current node is randomly selected for expansion until the preset traversal stop criterion is met. By generating multiple differentiated sub-topologies, the system significantly enhances its adaptability to network fluctuations and improves the stability and reliability of fault prediction.

[0093] Figure 4The core processing mechanism and technical features of the sparse gated residual graph attention layer are fully demonstrated. The upper left part shows the input node set, which includes all nodes obtained from the sub-topology and their current feature vectors. The sparse gated residual graph attention layer first traverses each connecting edge in the current sub-topology and calculates the edge correlation based on the feature vectors of the connected two-end nodes. The upper middle part shows the edge correlation calculation process. The system sorts all connecting edges in descending order according to the edge correlation value, generates an edge correlation sorted list, and divides the connecting edges into three levels: high correlation edges, medium correlation edges, and low correlation edges. The upper right part details the working principle of the gated shielding mechanism. The system performs low correlation screening on the edge correlation sorted list, identifies all connecting edges with correlation below the preset low correlation threshold, marks these connecting edges as low correlation edges, and generates the corresponding gated shielding mask inside the sparse gated residual graph attention layer. The gated masking mechanism activates gated masking for low-correlation edges based on a mask, blocking their weight updates and feature propagation paths in this round of information transfer. High-correlation edges, represented by solid lines, continue to propagate normally, while low-correlation edges, represented by dashed lines, are masked. The middle panel illustrates the residual pathway's mechanism for preserving original features. The sparse gated residual graph attention layer establishes a residual pathway for each node, passing the original input feature vector directly to the next processing stage, bypassing the graph attention mechanism. The middle right panel shows the feature aggregation process, applying the graph attention mechanism to unmasked high-correlation edges, distributing attention weights between them, and performing adjacency-based feature aggregation to obtain intermediate node representations that incorporate local contextual information. The bottom panel illustrates the fusion and normalization process. At each node, the intermediate node representation is element-wise superimposed with the feature vector retained by the residual pathway, and the superposition result is normalized to obtain the first-stage fused features. The bottom part describes the global context diffusion process. The global context diffusion process is executed based on the fused features in the first stage. Each node of the current sub-topology is used as the diffusion starting point. Diffusion-merging cycles are performed alternately between two adjacent layers of nodes, continuously shielding low-correlation edges and keeping the residual path connected. Finally, a high-order node representation that fuses local context information and global context information is output.

[0094] Figure 5The technical advantages of the method of the present invention are comprehensively evaluated from the two dimensions of overall system performance and long-term operation effect. The performance index comparison table in the upper half systematically shows the detailed comparison results of six key evaluation indicators. The traditional method in the figure is a detection method based on statistical analysis. In terms of fault prediction accuracy, the detection method based on statistical analysis can only achieve an accuracy of 78%, while the method of the present invention significantly improves the accuracy to 94% through the combination of edge computing real-time processing, multi-scale empirical mode decomposition feature extraction, sparse gated residual map attention layer modeling and LSTM time series prediction, achieving a 16% performance improvement. In terms of response time indicators, the detection method based on statistical analysis requires 15 seconds of processing time, which is difficult to meet the needs of real-time monitoring. The method of the present invention compresses the response time to 2 seconds through the local rapid self-test mechanism of the edge node, shortening it by 87%, realizing real-time fault detection in the true sense. In terms of false alarm rate, the 12% false alarm rate of the detection method based on statistical analysis can easily lead to waste of operation and maintenance resources and a decrease in system credibility. The method of the present invention reduces the false alarm rate to 3% through precise multi-dimensional weight mask generation and confidence vector analysis, reducing false alarms by 75%. The system stability evaluation shows that the detection method based on statistical analysis performs generally well when the network fluctuates and the device status changes, while the method of the present invention significantly improves the stability of the system in a complex network environment by generating multiple differential sub-topologies through Monte Carlo clipping. In terms of computing resource consumption, the detection method based on statistical analysis requires a large amount of central processing resources, while the edge computing architecture of the present invention distributes computing tasks to each edge node, reducing the overall computing resource consumption by 60%. The network fluctuation adaptability index reflects the robustness of the system when the power grid topology changes. The method of the present invention achieves significant improvements through dynamic adjacency graph generation and gated residual mechanism. The fault prediction accuracy trend comparison chart in the lower half shows the performance change trajectory of the two methods during the 12-month operation. The accuracy curve of the detection method based on statistical analysis is relatively flat, slowly increasing from 73% in the early stage to 78%, with a limited improvement and a performance bottleneck. The accuracy curve of the method of the present invention shows a clear upward trend, rapidly increasing from 85% in the early stage to 94%, demonstrating excellent learning ability and adaptability. Long-term operation data proves that the method of the present invention not only has performance advantages in the initial stage, but more importantly, it has the ability of continuous optimization and self-improvement. As the operating time increases, the system continuously learns and optimizes the model, and the fault prediction accuracy shows a good trend of steady increase, which fully reflects the long-term value of the integration of edge computing and deep learning technology.

[0095] Although specific embodiments of the present invention have been described above, those skilled in the art will appreciate that these specific embodiments are merely illustrative, and that those skilled in the art may omit, substitute, and modify the details of the methods and systems described above without departing from the principles and spirit of the present invention. For example, combining the above method steps to perform substantially the same functions in substantially the same manner to achieve substantially the same results falls within the scope of the present invention. Accordingly, the scope of the present invention is limited solely by the appended claims.

Claims

1. The electric energy meter self-detection and fault prediction method based on edge computing is characterized by: It includes: Step S1: The master cloud platform sends a self-test model package that matches the specifications of the electric energy meter to each edge node installed in the electric energy meter concentrator; the self-test model package includes: an encrypted handshake file and an inference engine; Step S2: The edge node completes the communication connection with the master cloud platform through an encrypted handshake file, then calls the inference engine to perform multi-scale empirical mode decomposition on the multiple electric energy meter operation data obtained by real-time sampling to obtain a multi-dimensional weight mask, thereby completing local rapid self-check, confirming the multi-dimensional weight mask as a confidence vector and outputting it; Step S3: After the master cloud platform receives the confidence vectors from all edge nodes, it dynamically generates an adjacency graph for each electricity meter based on the physical distance and phase coupling of the electricity meter, and forms multiple different sub-topologies through Monte Carlo pruning to improve the robustness to network fluctuations; then, a sparse gated residual graph attention layer is introduced on each sub-topology to perform gated shielding on low-correlation edges and retain the original features using residual paths, thereby extracting high-order node representations that integrate local and global contexts; each edge node inputs the obtained high-order node representation into the local LSTM to capture its own short-term fluctuations and long-term trends, and then uploads the output vector to the master cloud platform, which uses the master cloud platform LSTM to perform cross-node timing modeling and generate global fault predictions.

2. The method for self-checking and fault prediction of electric energy meters based on edge computing according to claim 1, characterized in that: Step S1 includes: the master station cloud platform registers the self-test model package with a number, and creates a task record for each edge node in the master station cloud platform task list; the master station cloud platform initiates a connection request to the edge node installed in the electricity meter concentrator, and the edge node accepts the connection request and returns the reception readiness information; the master station cloud platform sends the encrypted handshake file to the edge node, and the edge node immediately uses the locally stored master station public key to verify the integrity of the encrypted handshake file after receiving it, and returns the verification result; when the master station cloud platform receives the verification success information returned by the edge node, the master station cloud platform starts to send the inference engine blocks to the edge node; after all blocks are sent, the master station cloud platform sends a transmission end identifier to the edge node; after receiving all the inference engine blocks and completing the reorganization, the edge node performs an integrity check on the inference engine; when the verification passes, the edge node merges the encrypted handshake file with the inference engine to form a complete local copy of the self-test model package, and returns confirmation information to the master station cloud platform.

3. The electric energy meter self-test and fault prediction method based on edge computing according to claim 2, characterized in that: The process of the edge node reorganizing the inference engine blocks includes: after receiving each inference engine block, writing the inference engine block into the local temporary buffer according to its sequential number, and generating a temporary file index table entry for each inference engine block; immediately performing a single block integrity check on the inference engine block just written; if the check fails, sending a retransmission request to the main station cloud platform through the existing connection until the inference engine block check is successful; when it is detected that the number of inference engine blocks in the temporary file index table is exactly the same as the total number marked by the main station cloud platform in the encryption handshake file, entering the overall reorganization process; if the number is inconsistent, continue to wait for the arrival of the remaining inference engine blocks; sort the temporary file index table according to the sequential number of the inference engine blocks; after the sorting is completed, the edge node reads the contents of each inference engine block in turn and writes them into the reorganization buffer, and performs an overall integrity check on the inference engine in the reorganization buffer; if the overall integrity check fails, the edge node deletes the reorganization buffer; if the overall integrity check succeeds, the inference engine that passes the overall integrity check is moved from the reorganization buffer to the local storage partition.

4. The electric energy meter self-test and fault prediction method based on edge computing according to claim 3, characterized in that: In step S2, the process of calling the inference engine and performing multi-scale empirical mode decomposition on the multiple electric energy meter operation data obtained by real-time sampling includes: the edge node calls the inference engine and writes the multiple electric energy meter operation data obtained by real-time sampling into the local ring buffer in the order of arrival; the analysis window is divided according to the fixed time span in the ring buffer, and a sequential index is established for each analysis window. The inference engine scans the current analysis window in turn, marks all local maximum points and local minimum points, connects the local maximum points and local minimum points through the interpolation curve, obtains the upper envelope curve and the lower envelope curve, and samples the corresponding upper envelope curve and the lower envelope curve. points, and calculate the point-by-point mean curve of the two to provide a reference baseline for removing local trends; subtract the mean curve from the original electricity meter operating data of the current analysis window point by point to generate modal components; write the modal components into the modal result list, and at the same time subtract the modal components from the original electricity meter operating data of the current analysis window to obtain a new residual sequence; if the residual sequence still contains decomposable information, the inference engine returns to sub-step S23 to start the next level of decomposition; if the residual sequence is monotonic, the multi-scale empirical mode decomposition of the current analysis window is terminated; all modal components and the final residual sequence obtained in the current analysis window are combined into a multidimensional feature tensor in the order of generation.

5. The electric energy meter self-test and fault prediction method based on edge computing according to claim 4, characterized in that: In step S2, the process of completing local quick self-check and outputting the confidence vector includes: searching the historical baseline matching template in the historical baseline library and comparing it with the multidimensional feature tensor by cosine similarity; confirming the historical baseline matching template with the highest cosine similarity as the best matching template; and generating a multidimensional weight mask as the confidence vector based on the degree of deviation between the best matching template and the multidimensional feature tensor in each dimension.

6. The electric energy meter self-test and fault prediction method based on edge computing according to claim 5, characterized in that: In step S3, the master cloud platform retrieves the physical location information and phase connection information of each energy meter from its pre-stored energy meter equipment list, establishes an initial node with each energy meter as the center, and assigns an eigenvalue vector to the initial node based on the confidence vector of each energy meter; the initial node set is represented as an energy meter topology basic graph, in which each node exists independently and has no edge connection; the master cloud platform performs neighbor node expansion on each energy meter node in the energy meter topology basic graph, including: taking the current node to be expanded as the starting node, calculating the physical space between the current node and all other nodes, and then performing the neighbor node expansion. The physical proximity distance between the candidate neighbor nodes is determined, and all candidate neighbor nodes whose physical distance is less than the physical proximity threshold preset by the master station cloud platform are screened out; the grid phase connection information of the candidate neighbor nodes is compared with the grid phase connection information of the current node one by one to determine whether there is a phase coupling relationship between each candidate neighbor node and the current node, including: if the candidate neighbor node and the current node are located in the same grid phase branch or there is a clear electrical connection path between different grid phase branches, then it is considered that there is a phase coupling relationship between the candidate neighbor node and the current node; otherwise, it is considered that there is no phase coupling relationship and the candidate neighbor node is discarded.

7. The electric energy meter self-test and fault prediction method based on edge computing according to claim 6, characterized in that: In step S3, the master station cloud platform calculates the similarity of the confidence vector between the candidate neighbor node and the current node for the candidate neighbor node that satisfies both the physical proximity condition and the phase coupling relationship; If the confidence vector similarity is higher than the pre-defined confidence vector similarity threshold, the master cloud platform confirms the candidate neighbor node as a valid neighbor node, connects it to the current node, and updates the current node adjacency graph; otherwise, no node connection is established; Until all nodes in the electricity meter topology basic graph have completed neighbor node expansion and a complete adjacency graph set is obtained, the master station cloud platform performs a Monte Carlo pruning process on the adjacency graph set. The specific Monte Carlo pruning process is as follows: the master station cloud platform randomly selects a starting node in the adjacency graph as the starting node of the random traversal; starting from the starting node, the traversal path is gradually expanded in a random manner. Each time the traversal is expanded, the neighbor node of the current node is randomly selected and expanded to the neighbor node; After each expansion, check whether the traversal path length and the number of nodes reach the pre-set traversal stop criteria. If the stop criteria are met, stop the traversal immediately and generate the current sub-topology; If the stopping criterion is not met, the expansion continues.

8. The electric energy meter self-checking and fault prediction method based on edge computing according to claim 7, characterized in that: In step S3, the master cloud platform instantiates a sparse gated residual graph attention layer for each generated sub-topology, and uses all nodes in the sub-topology and their current feature vectors as the input node set of the sparse gated residual graph attention layer; The sparse gated residual graph attention layer traverses each connection edge in the current sub-topology, calculates the edge correlation based on the feature vectors of the connected two-end nodes in the input node set, sorts all the connection edges in descending order according to the value of the edge correlation, and generates an edge correlation sorted list; performs low correlation screening on the edge correlation sorted list, identifies all connection edges with a correlation lower than a pre-set low correlation threshold, marks these connection edges as low correlation edges, and generates the corresponding gated shielding mask inside the sparse gated residual graph attention layer; The sparse gated residual graph attention layer activates the gated shielding mechanism for low-correlation edges according to the gated shielding mask, blocking the weight update and feature propagation path of low-correlation edges in this round of information transmission. It applies the graph attention mechanism to the unshielded high-correlation edges, distributes attention weights among the high-correlation edges, and performs feature aggregation based on adjacency to obtain intermediate node representations that incorporate local context information. At the same time, the sparse gated residual graph attention layer establishes a residual path for each node, passing the original input feature vector directly to the next processing stage bypassing the graph attention mechanism.

9. The electric energy meter self-test and fault prediction method based on edge computing according to claim 8, characterized in that: In step 3, at each node, the intermediate node representation and the feature vector retained by the residual path are superimposed element by element, and the superposition result is normalized to obtain the first stage fusion feature; After the normalization process is completed, the sparse gated residual map attention layer stores the first stage fusion features into a temporary feature buffer; The sparse gated residual graph attention layer performs a global context diffusion process based on the fused features in the first stage: taking each node of the current sub-topology as the diffusion starting point, a diffusion-merging cycle is performed alternately between the nodes of two adjacent layers; in each diffusion process, the sparse gated residual graph attention layer reuses the gated shielding mechanism to ensure that low-correlation edges are continuously shielded on the global diffusion path and the residual path is kept connected; in each merging process, the sparse gated residual graph attention layer again superimposes and normalizes the node features obtained by diffusion with the accumulated features in the residual path, and outputs the final node feature vector that fuses local context information and global context information as the high-order node representation of the sub-topology.

Images