Fault diagnosis method for electricity utilization information acquisition terminal

Abstract

The invention discloses an electricity consumption information acquisition terminal fault diagnosis method, and relates to the technical field of electric power information acquisition. The method comprises the following steps: acquiring multi-modal time sequence data, extracting communication session anchor points, performing semantic alignment and merging based on the anchor points, and generating a standardized session sample sequence; coding the sample sequence, and constructing a cross-modal correlation structure reflecting a time sequence causal dependency relationship between modals, such as a causal matrix or a session relationship graph; performing causal-guided feature aggregation based on the structure to obtain a fusion feature vector; inputting the data into a double-end calibration diagnosis model, and respectively outputting a known fault probability and an unknown score; and mapping the unknown score into a probability, and performing consistency calibration on a known probability according to the probability to obtain a normalized fault probability vector. According to the method, the problem of asynchronous alignment of heterogeneous data is solved, and interpretable modeling of fault cross-modal conduction and accurate identification of open set faults are realized.

Description

Technical Field

[0001] This invention belongs to the field of power information acquisition technology, and in particular, it is a method for diagnosing faults in power information acquisition terminals. Background Technology

[0002] As the data sensing antenna of the smart grid, the stability of electricity information collection terminals directly affects the accuracy of electricity metering and the real-time monitoring of the power grid. With the construction of the ubiquitous power Internet of Things, collection terminals have evolved into edge computing nodes running complex operating systems and carrying high-concurrency communication protocols. Timely and automated accurate diagnosis of their faults can ensure the continuity of electricity marketing operations.

[0003] Currently, fault diagnosis for data acquisition terminals relies on manual maintenance or expert systems based on predefined rules, such as triggering alarms by detecting the duration of lost heartbeats or the number of failed file operations. Some research has begun to introduce machine learning or basic deep learning techniques, inputting single-dimensional performance data or simple log statistical features into LSTM (Long Short-Term Memory) networks or CNN (Convolutional Neural Networks) for supervised learning-based fault classification, achieving an initial shift from manual rules to data-driven approaches.

[0004] However, existing technologies face challenges in handling complex faults at data acquisition terminals, including difficulties in aligning the timing logic of multimodal heterogeneous data and the inexplicable nature of fault propagation mechanisms across modalities. Therefore, further research and innovation are needed to address these issues in existing technologies. Summary of the Invention

[0005] Purpose of the invention: In view of the above-mentioned problems in the prior art, this application provides a method for diagnosing faults in an electricity information collection terminal.

[0006] Technical solution: On the one hand, a fault diagnosis method for an electricity information collection terminal, including:

[0007] Multimodal time-series data from electricity consumption information collection terminals are acquired, communication session anchors are extracted from them, and semantic alignment and merging of multimodal time-series data are performed based on the communication session anchors to obtain a standardized session sample sequence.

[0008] Feature encoding is performed on standardized conversation sample sequences to construct a cross-modal association structure that reflects the temporal causal dependencies between modalities;

[0009] Based on this, causal-guided feature aggregation and updating are performed on features of different modalities to obtain a fused feature vector containing cross-modal causal transmission information;

[0010] The fused feature vector is input into the dual-head calibration diagnostic model, which outputs a known fault probability through the known classification head and an unknown score through the unknown detection head.

[0011] The unknown scores are mapped to calibrated unknown failure probabilities, and the known failure probabilities are then calibrated for consistency to obtain a failure probability vector that satisfies the normalization constraints.

[0012] Beneficial effects: This invention solves the problem of asynchronous alignment of heterogeneous data, and realizes interpretable modeling of fault cross-modal propagation and accurate identification of open set faults. The related technical effects will be described in detail below with reference to specific embodiments. Attached Figure Description

[0013] Figure 1 A flowchart of a fault diagnosis method for an electricity information collection terminal provided in an embodiment of this application.

[0014] Figure 2 This is a flowchart illustrating the extraction of communication session anchor points from multimodal time-series data, provided as an embodiment of this application.

[0015] Figure 3 This is a flowchart illustrating the construction of a cross-modal temporal causal correlation matrix provided in an embodiment of this application.

[0016] Figure 4 This is a flowchart illustrating the process of outputting an unknown score through an unknown detection head, as provided in an embodiment of this application.

[0017] Figure 5 This is a flowchart illustrating how an unknown score is mapped to a calibrated unknown fault probability and how known fault probabilities are calibrated accordingly, as provided in an embodiment of this application. Detailed Implementation

[0018] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0019] It should be noted that the terms "first," "second," etc., in the specification and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "including" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that includes a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0020] To address the aforementioned issues, the applicant conducted in-depth searches and analyses, and discovered:

[0021] Specifically, the business logs (event-driven), communication messages (burst interactions), and performance indicators (periodic sampling) of the acquisition terminal are severely out of sync in terms of time scale. The traditional fixed sliding window processing method based on absolute time is prone to cutting off the business logic chain such as request-response, resulting in the loss of semantic context during feature extraction.

[0022] Furthermore, simple feature splicing and fusion ignores the latency patterns and causal dependencies of fault propagation between different hardware and software modules. For example, a disk write delay of several seconds can cause a communication protocol timeout, making it impossible for the model to distinguish between the root cause and the symptoms of the fault. Moreover, when faced with unknown new fault modes, the lack of a probability calibration mechanism can lead to high-confidence misjudgments.

[0023] To solve these problems, combined with Figures 1 to 5 The present invention will be specifically described through the following embodiments.

[0024] In some embodiments, an exemplary scheme for fault diagnosis of an electricity information collection terminal is provided. This method can solve the problems of difficulty in asynchronous alignment of multimodal data, difficulty in modeling cross-modal causal relationships, and non-normalization of open set fault probabilities.

[0025] Step S101: Obtain multimodal time-series data from the electricity information collection terminal, extract communication session anchors from the data, and perform semantic alignment and merging on the multimodal time-series data based on these (communication session anchors) to obtain a standardized session sample sequence.

[0026] In this embodiment, the electricity information collection terminal may include, but is not limited to, devices with data collection and edge computing capabilities such as smart meter concentrators, dedicated transformer collection terminals, and energy controllers. Multimodal time-series data refers to operational data with heterogeneous sources, different sampling frequencies, and time-series attributes, specifically including business log sequences, performance indicator time-series data, communication message sequences, and system event streams.

[0027] Among them, business log sequences are usually unstructured text records, performance indicator time series data are periodically sampled values, such as CPU utilization and memory usage, communication message sequences are discrete events containing requests and responses, and system event streams are sparse records of specific state changes.

[0028] Specifically, a communication session anchor point is a time reference point determined based on a complete communication interaction process (i.e., request-response). Since electricity information collection terminals communicate frequently with the master station or electricity meters, and communication activities can easily trigger system resource consumption and generate logs, using communication sessions as anchor points for data alignment can associate multimodal data at the semantic level rather than the physical time level.

[0029] Extracting communication session anchors can be achieved by identifying request and response messages with the same transaction identifier. For example, when a request message and a response message with the same message identifier (msgId) are collected, the session anchor can be determined.

[0030] Among them, semantic alignment and merging of multimodal time-series data based on communication session anchor points refers to establishing an elastic time window with the session start time as the starting point and the session end time or timeout time as the ending point. All logs, performance data points, events, etc. falling within this time window are merged into this session to form a standardized data unit containing multimodal information, namely a standardized session sample.

[0031] Performing this operation on all historical data yields a standardized sequence of session samples. This process transforms asynchronous, high-frequency data streams into synchronous sequences organized by business logic, facilitating subsequent model processing.

[0032] Step S102: Encode the standardized session sample sequences by feature to construct a cross-modal association structure that reflects the temporal causal dependency between modalities.

[0033] In this step, feature encoding can transform raw data from different modalities into feature vectors of a uniform dimension. For numerical performance data, a one-dimensional convolutional neural network (1D-CNN) can be used for encoding; for textual logs or event sequences, a long short-term memory network (LSTM) or a Transformer encoder can be used.

[0034] The cross-modal correlation structure is a mathematical or logical structure used to explicitly express the causal relationship between different modes. In one implementation, this structure can be a cross-modal temporal causal correlation matrix, where the elements represent the causal strength of the source mode on the target mode at a specific time delay.

[0035] In another implementation, the structure can be a session graph, where nodes represent data segments from different modalities, and edges represent causal or temporal relationships between data segments. Regardless of the form, the goal is to capture the propagation patterns of fault signals between modalities, such as excessive CPU load (performance modality) causing subsequent communication timeouts (communication modality).

[0036] Step S103: Based on this (cross-modal association structure), causal-guided feature aggregation and updating are performed on the features of different modalities to obtain a fused feature vector containing cross-modal causal transmission information.

[0037] Specifically, causal-guided feature aggregation and updating utilizes the causal strength information contained in the cross-modal association structure to guide the feature fusion process. If the cross-modal association structure shows that modality A has a strong causal influence on modality B, then features from modality A are given higher weights when updating the features of modality B. This mechanism is similar to the attention mechanism, but its attention weights are not adaptively learned from the data; instead, they are constrained and guided by the causal structure.

[0038] Furthermore, causal-guided feature aggregation and updating ensure that the generated fused feature vector not only contains the original information of each modality but also encodes the dynamic causal interaction information between modalities, enabling a more accurate characterization of complex fault patterns. For example, the fused feature vector can distinguish between simple communication timeouts and communication timeouts caused by disk failures.

[0039] Step S104: Input the fused feature vector into the dual-head calibration diagnostic model, output the known fault probability through the known classification head, and output the unknown score through the unknown detection head; map the unknown score to the calibrated unknown fault probability, and perform consistency calibration on the known fault probability based on this (calibrated unknown fault probability) to obtain a fault probability vector that satisfies the normalization constraint.

[0040] In this embodiment, the dual-head calibration diagnostic model refers to a model architecture that sets up two output branches in parallel after the feature extraction layer. The known classification head typically uses a fully connected layer with a Softmax activation function; where Softmax, or normalized exponential function, is used to identify fault types already existing in the training set, such as uplink communication anomalies, storage faults, etc., and outputs the original probability distribution for known types. The unknown detection head is used to assess the probability that the current sample belongs to an unknown fault mode, i.e., an anomaly not present in the training set, and outputs a non-normalized unknown score.

[0041] Furthermore, this step introduces a consistency calibration mechanism to address the issue that the traditional Softmax function cannot handle open set data. Accordingly, a pre-defined mapping function, such as the Sigmoid function (i.e., the sigmoid activation function), is used to convert the unknown scores into calibrated unknown fault probabilities between 0 and 1.

[0042] Next, the probability output by the known classification head is scaled using this unknown fault probability. For example, if the unknown fault probability is 0.2, the sum of the known fault probabilities is compressed to 0.8. The resulting fault probability vector contains the probabilities of all known fault types and the probability of unknown faults, and the sum of all components is strictly equal to 1. This gives the diagnostic results a mathematically rigorous probabilistic interpretation, indicating whether there are unknown potential risks in the system.

[0043] In other embodiments, the specific implementation process of session alignment for multimodal data is described, particularly the logic for extracting communication session anchors and the encoding methods for log and performance data. Accordingly, this embodiment can be implemented by performing the following steps:

[0044] Step S201: Parse the communication message sequence from the multimodal time-series data, identify request messages and response messages with the same transaction identifier, and pair them as session units.

[0045] In this embodiment, the communication message sequence refers to the data stream captured from the terminal's communication interface (such as a 4G / 5G module or Ethernet interface). Each message typically includes a timestamp, message type, direction (send / receive), transaction identifier (TransactionID, such as msgId or sequence number), and payload content. The transaction identifier is a tag used to uniquely associate a request with its corresponding response.

[0046] For example, a terminal sends a request message to the master station with a msgId of A1001; subsequently, the master station returns a response message with the same msgId. The system iterates through the message sequence, searching for a pair of messages with the same msgId, and identifies them as a session unit. One-way messages that do not require a response (such as broadcast messages) can be considered as special single-frame session units.

[0047] Step S202: Calculate the time interval between adjacent session units. When the time interval exceeds the preset session timeout threshold, determine the session boundary and generate a communication session anchor point containing the session start and end time and the session identifier.

[0048] Specifically, to handle potential packet loss or timeouts during communication, a timeout truncation mechanism needs to be introduced. The preset session timeout threshold can be set according to the communication protocol specifications, for example, to 60 seconds. During processing, if a request message is sent but no corresponding response message is received within the session timeout threshold period, or if the time difference between two adjacent unrelated messages exceeds the threshold, the system will determine that the current session has ended, or that the previous session has terminated abnormally.

[0049] After determining the session boundaries, the system generates a communication session anchor point, which includes the session start time (t). _start ), end time (t) _end ) and a unique session identifier (SessionID). This time interval [t _start , t _end The (or expanded elastic window) will serve as the benchmark for subsequent adsorption of other modal data.

[0050] In some scenarios, the session time window can be designed as a flexible window, that is, within [t _start , t _end Expanding forward (e.g., 10 seconds) and backward (e.g., 15 seconds) from the previous window allows for a more complete capture of the causal chain of the fault. For cases where two adjacent session windows overlap, a soft allocation strategy can be used to handle the data in the overlapping region. For example, for a data point x within the overlapping region, its weight w belonging to session k... _k (x) can be calculated using the following formula:

[0051] w _k (x)=exp(-λ×|t _x -t _center_k |) / (exp(-λ×|t _x -t _center_k |)+exp(-λ×|t _x -t _center_k+1 |));

[0052] Among them, w _k (x) represents the attribution weight assigned to session k for data point x, t _x The timestamp of the data point, or the sampling timestamp of data point x, t _center_k Let t be the center time of session k, λ be the decay coefficient used to control how quickly the weight decreases over time, and t be the center time of session k._center_k t represents the time at the center of the time window for session k; _center_k+1 Let |...| represent the time at the center of the time window between adjacent sessions (k+1), and |...| represent absolute value operations. In other words, the above formula can also be called the soft-weighting formula when session windows overlap. This approach avoids information loss caused by hard segmentation.

[0053] Based on this, semantic alignment and merging of multimodal time-series data can be performed using communication session anchors. This includes templated encoding of business logs within the time window corresponding to the communication session anchor, which can be achieved in the following ways:

[0054] Optionally, identify dynamic parameters in the business logs and replace them with type placeholders to generate a log template ID.

[0055] Business logs typically contain a large amount of unstructured text, including both fixed descriptive text and dynamically changing parameters such as IP addresses, error codes, and file paths. Therefore, templated processing is necessary.

[0056] For example, for the original log "2024-01-15 ERROR: Write failed, path= / data / log.txt,errno=28", the system recognizes that / data / log.txt is a path-type dynamic parameter and 28 is a numeric-type dynamic parameter. After replacing these with placeholders, the log template ERROR:Writefailed, path= is obtained. <path>,errno= <num>Furthermore, the system maintains a template library, assigning a log template ID, such as TPL_005, to each unique template.

[0057] In some alternative implementations, a clustering algorithm based on edit distance can also be used to merge templates, which can reduce the number of templates and improve generalization ability. Accordingly, for two templates T... _i and T _j The normalized edit distance can be calculated using the following formula:

[0058] d _edit (T _i T _j =EditDistance(T _i T _j ) / max(len(T _i ), len(T _j ));

[0059] Above, d _edit (T _i T _j ) is the log template T _i With log template T _j Normalized edit distance between them;

[0060] EditDistance(T _i T _j ) is the Levenshtein distance for calculating the difference between two template strings (i.e., the minimum number of insertions, deletions, and replacements required to transform one string into the other); max(...) is the function to find the maximum value; len(T) _i ) is the log template T _i The length of the character string; len(T) _j ) is the log template T _j The length of the characters.

[0061] When the normalized edit distance is less than a preset threshold (e.g., 0.15), the two templates are considered to be of the same type and merged into a general template.

[0062] Optionally, statistical features of dynamic parameters can be extracted to generate parameter signature vectors.

[0063] Although the dynamic parameters extracted from the logs are replaced during the template generation stage, their specific values ​​often contain important fault information. For example, errno=28 indicates a full disk, and errno=5 indicates an I / O error. Therefore, it is necessary to extract their statistical characteristics separately.

[0064] For numerical parameters, their mean, variance, and maximum value can be calculated; for string parameters, their length can be calculated. The statistical values ​​are assembled into a fixed-dimensional vector, namely the parameter signature vector (v...). _param For example, v _param This can be represented as [number of values, average number of values, number of path parameters, average string length].

[0065] Optionally, the embedding vector of the log template ID is concatenated with the parameter signature vector to generate an event token sequence for the business log, which is then used as part of a standardized session sample sequence.

[0066] Furthermore, the system maps the log template ID to a dense vector v through an embedding layer. _tpl Additionally, the system can extract log levels (v). _level ) and module source (v _module The embedding vector of the log vector e. _i The concatenation of the above vectors can be represented as:

[0067] e _i =[v _tpl ||v _level ||v _module ||v _param ];

[0068] Among them, e _i The final event token vector generated for the i-th business log, [...] represents the vector concatenation operation, v _tpl The embedding vector is obtained by mapping the log template ID through the embedding layer, v _level For each log level (e.g., INFO / ERROR), v is the embedding vector. _module For the embedding vector corresponding to the software module that generates the logs (such as Protocol / Disk), v _param It is a parameter signature vector composed of the statistical characteristics of dynamic parameters.

[0069] For example, if v _tpl The dimension is 32, v _level Dimensions are 8, v _module The dimension is 16, v _param With a dimension of 8, the resulting log vector has a dimension of 64. These vectors, arranged chronologically, correspond to all log lines within the session window and form the event token sequence.

[0070] Based on this, semantic alignment and merging of multimodal time-series data are performed using communication session anchors. This includes multi-granular aggregation of performance indicator time-series data merged into the time window corresponding to the communication session anchor, specifically:

[0071] Optionally, the time window can be divided into multiple segments, and local statistical features within each segment can be calculated.

[0072] For high-frequency sampled performance metrics, such as CPU utilization per second, directly inputting the full sequence would result in excessively high dimensionality. Therefore, this step employs a multi-granularity aggregation strategy. Accordingly, the session's time window is divided into N equal-length segments (e.g., N=4). For the sampled point sequence within each segment, its local statistical characteristics, such as local mean, local maximum, and local minimum, are calculated to preserve the data's fluctuation information at a fine-grained level.

[0073] Optionally, global statistical features are calculated over the entire time window, including at least the slope reflecting the overall trend of change or the volatility reflecting the degree of fluctuation.

[0074] Building upon segment statistics, the system also needs to extract global features across the entire window. The slope, reflecting the overall trend, can be obtained by linearly fitting all data points within the window, indicating whether the performance indicator is rising, falling, or stable. The volatility, reflecting the degree of fluctuation, can be obtained by calculating the standard deviation of the first difference. Furthermore, the global mean, global variance, and coefficient of variation can also be calculated.

[0075] Optionally, local statistical features can be combined with global statistical features to generate a sequence of numerical tokens with relative timestamps, which can be used as part of a standardized session sample sequence.

[0076] Based on this, the system concatenates or combines the local and global statistical features of each sub-segment to form a comprehensive representation of the performance data under that session window, namely, a sequence of numerical tokens. To preserve timing information, each token is also appended with a relative timestamp, which is an offset relative to the session start time.

[0077] In this embodiment, multimodal data is transformed into a standardized conversation sample sequence with unified structure and semantic alignment, laying the data foundation for subsequent causal association analysis.

[0078] In other embodiments, specific neural network architectures for extracting multimodal deep features are described, and specific model configuration parameters are provided as optional implementation methods.

[0079] In this embodiment, parallel feature extraction branches are designed for different data type modalities. For the numerical token sequences generated by performance metrics, a one-dimensional convolutional neural network (1D-CNN) branch can be used for encoding. Specifically, this branch can contain three stacked convolutional layers. The first layer has 64 kernels, a kernel size of 3, a stride of 1, and uses ReLU (Modified Linear Unit) activation function to extract fine-grained local fluctuation features. The second layer has 128 kernels to combine low-level features. The third layer has 256 kernels to extract high-level abstract features. A global max pooling layer is connected after the convolutional layers to map the variable-length sequence features into fixed-dimensional vectors.

[0080] For event token sequences generated from business logs and system events, a bidirectional long short-term memory (Bi-LSTM) branch can be used for encoding. Specifically, this branch can contain two stacked LSTM layers, with each layer having 128 hidden units. The bidirectional structure allows the model to utilize both forward and backward contextual information simultaneously, capturing long-distance dependencies between log events. Furthermore, a random dropout rate of 0.3 is set between layers to prevent overfitting.

[0081] In one possible implementation, the feature encoder can also employ a Transformer architecture. For example, a two-layer Transformer Encoder block could be used, with four heads for the multi-head attention mechanism and a feedforward network dimension of 512. Regardless of the architecture used, the feature vectors output from each branch are mapped to a uniform dimension D (e.g., D=128) through fully connected layers to facilitate subsequent cross-modal fusion.

[0082] An example illustrates an optional fusion scheme based on a cross-modal temporal causal correlation matrix. It is suitable for explicitly modeling fault propagation scenarios with fixed time delays.

[0083] The scheme constructs a cross-modal correlation structure reflecting the temporal causal dependencies between modalities. Specifically, it constructs a cross-modal temporal causal correlation matrix, and the construction process includes:

[0084] Define the modality set and the preset time delay search range;

[0085] Calculate the causal correlation strength between the source mode and the target mode under multiple time delays within the time delay search range;

[0086] Select the causal correlation strength corresponding to the optimal time delay and construct a cross-modal temporal causal correlation matrix. The elements in the cross-modal temporal causal correlation matrix represent the causal influence weight of the source mode on the target mode under the optimal time delay.

[0087] In this embodiment, the modality set M includes performance (perf), log, communication (comm), and event. The preset latency search range T can be set to {0, 1, 2, ..., τ}. _max }, where τ _max This represents the maximum causal delay window.

[0088] For example, considering that the propagation of terminal faults typically takes 30 seconds, τ _max This can be set to 30 (in seconds or sampling periods). The system needs to iterate through every integer delay within this range to calculate the causal correlation strength between the source mode and the target mode. Furthermore, the optimal delay is selected based on the principle of maximizing the correlation strength, that is, selecting the delay that makes the correlation strength reach its peak.

[0089] The constructed cross-modal temporal causal correlation matrix C is an asymmetric matrix of |M|×|M|, where the elements C _ij It records the weight of the maximum causal influence of mode i on mode j. For example, if matrix element C _perf→log =0.82, and the corresponding optimal latency is 2s, indicating that the performance metric anomaly strongly triggered a log anomaly after 2 seconds. Among them, C _perf→log The weight of the corresponding performance impact on logs.

[0090] The calculation of the causal correlation strength between the source mode and the target mode under multiple time delays within the time delay search range includes:

[0091] For each time delay, extract the feature vector of the source mode at the current time and the feature vector of the target mode after the time delay;

[0092] The two extracted feature vectors are input into a causal association function containing a learnable time delay bias parameter to calculate the time-level association score.

[0093] The temporal correlation scores are aggregated and calculated along the time dimension to obtain the global causal correlation strength between the source mode and the target mode under time delay.

[0094] Specifically, to calculate the correlation strength between the source mode and the target mode under a specific time delay, this step employs a calculation method based on a gating mechanism. Assume the eigenvector of the source mode at time t is h. _i (t), the eigenvector of the target mode at time t+τ is h _j (t+τ). The causal relationship function can be specified by the following formula:

[0095] s i→j τ (t)=σ(W _c ×[h _i (t)||h _j [(t+τ)]+b _τ );

[0096] Among them, s i→j τ (t) corresponds to the instantaneous correlation score of source mode i to target mode j at time t under time delay τ, [...] represents vector concatenation, W _c It is a learnable weight matrix, b _τ σ is a learnable bias parameter for a specific time delay τ, and σ is the Sigmoid activation function used to constrain the output within the (0, 1) interval. The time-level correlation score s i→j τ (t) reflects the degree of matching between the two modes under time delay τ at the instant of time t. To obtain a globally robust evaluation, aggregation of the time dimension is required. For example, an average aggregation method can be used, with the specific formula as follows:

[0097] C i→j τ =(1 / (T-τ))×∑ _t=1 T-τ s i→j τ (t);

[0098] In the formula, C i→j τ Let τ be the global causal correlation strength between source mode i and target mode j under time delay; T is the total time step of the current session sample sequence; ∑ _t=1 T-τ This indicates that the summation is performed over time step t from 1 to T-τ.

[0099] Through this calculation, the model can automatically learn the time delay patterns between different modalities. For example, the model will learn b _2 A large positive value in the performance-log pair increases the correlation strength when τ=2. Where b _2 Corresponding to b _τ , τ=2.

[0100] Furthermore, causal-guided feature aggregation and updating specifically include:

[0101] The elements in the cross-modal temporal causal correlation matrix are used as weights to weight the features of different modalities;

[0102] For any target modality, its own feature vector is concatenated or summed with the causal weighted features from other modalities; or, in other words, the updated target modality feature vector is obtained here.

[0103] Among them, the causal weighted feature is obtained by multiplying the feature vectors of other modes by their causal influence weights on the target mode after feature transformation.

[0104] In this embodiment, feature aggregation is implemented using dynamic routing based on a causal matrix. For the target modality, its fused feature vector H _j The calculation process for ' is as follows:

[0105] H _j '=H _j +∑ _i≠j (C i→j ×φ(H _i ));

[0106] Among them, H _j It is the original feature of the target mode, C i→j The causal weights are obtained from the causal matrix, and φ(.) is the feature transformation function (e.g., in a single-layer linear network) used to align the feature space of the source mode to the target mode. In other words, H _j ' is the feature vector after fusing the target mode j; ∑ _i≠j This indicates that the summation is performed on all source modes i that are not j; C i→j H represents the optimal causal influence weight of mode i on mode j in the cross-modal temporal causal correlation matrix; φ(...) is the feature transformation function (such as linear transformation) used to align the source mode features to the target mode space; _i Let be the original feature vector of source mode i.

[0107] Furthermore, if the causality matrix indicates that mode i is a strong cause of mode j, i.e., C i→j The value of mode i is very large. When judging the state of mode j, the model will pay close attention to the features of mode i; conversely, if there is no causal relationship between the two, the information of mode i will be ignored.

[0108] For example, when diagnosing communication timeouts, if the causal matrix shows that performance metrics have a strong causal impact, the model will automatically incorporate the high CPU load features into the communication features to identify cascading failures caused by performance issues.

[0109] Optionally, a gating update mechanism can be added after the weighted summation to further enhance the model's nonlinear expressive power. For example, the update formula of the Gated Recurrent Unit (GRU) can be used, with the weighted summation term as input and the original features as the hidden state for updating.

[0110] Another example provides an optional implementation of a message passing fusion scheme based on session relationship graphs. It is suitable for scenarios with complex fault propagation paths and dynamically changing topologies. Specifically, it includes:

[0111] Step S501: Construct a cross-modal association structure reflecting the temporal causal dependencies between modalities. Specifically, this involves constructing a session relationship graph. The construction process includes:

[0112] Using the session corresponding to the communication session anchor point as the unit, the elements in the standardized session sample sequence are mapped to graph nodes. The graph nodes include event nodes that represent business logic, message nodes that represent communication interaction, and performance nodes that represent the running status.

[0113] Directed edges are constructed based on the semantic and temporal relationships between nodes. The directed edges include at least temporally adjacent edges connecting nodes with adjacent times, session causal edges connecting nodes with request-response or trigger relationships, and resource-related edges connecting performance anomalies and system events.

[0114] In this embodiment, the system constructs a local heterogeneous graph G=(V, E) for each communication session. The node set V contains three types of nodes: event nodes originating from logs and system events, message nodes originating from communication packets, and performance nodes originating from aggregated performance metrics. The edge set E contains directed edges of three semantic types, specifically:

[0115] A time-adjacent edge connects two nodes that are temporally adjacent within the same modality (e.g., log L). _t and L _t +1), used to model the temporal evolution within a mode;

[0116] A session-causal edge connects nodes that have a triggering relationship in business logic. The most typical examples are from the request message node to the response message node, and from the response message node to the subsequent processing log node.

[0117] Resource-Correlation Edge connects performance nodes with other modal nodes. When a performance metric (such as CPU) exceeds a warning threshold, an edge is connected from that performance node to a log or message node within the same time period to characterize the impact of resource contention on business.

[0118] This mapping method organizes discrete multimodal data into a logical topology network with clear physical meaning.

[0119] Step S502, perform causal-guided feature aggregation, specifically performing time-series message passing that distinguishes relation types, including:

[0120] For any target node in the session relationship graph, identify its neighboring nodes and the edge types of the connecting edges, and calculate the time difference between the target node and its neighboring nodes;

[0121] Calculate message propagation weights based on edge type and time difference, and aggregate information of neighboring nodes based on message propagation weights;

[0122] The feature representation of the target node is updated using the aggregated information to obtain the fused node feature vector.

[0123] Specifically, this step performs message passing using a graph neural network (GNN) on the constructed session relationship graph. To handle asynchronous temporal data, this embodiment employs a time-aware attention aggregation mechanism. For the target node v, its (l+1)th layer features h... v l+1 The updated formula is as follows:

[0124] h v l+1 =σ(∑ _u∈N(v) α _uv ×W _r ×h u l +W _0 ×h v l );

[0125] Where N(v) is the set of neighbors of node v, and W _r W is the transformation matrix related to the edge type r (i.e., different parameter matrices are used for different types of edges). _0 It is a self-updating matrix. That is, h v l+1 Let σ be the feature vector of the target node v in layer l+1; σ is the non-linear activation function (such as ReLU); ∑ _u∈N(v) This represents the summation of all neighboring nodes u of node v; α _uv For message propagation weight; W _r h is the characteristic transformation matrix corresponding to edge type r; u l The feature vector of neighbor node u at layer l; W _0 h is the self-updating weight matrix for each node; v l Let v be the feature vector of the target node v at layer l.

[0126] Among them, the message propagation weight α _uv The calculation depends not only on the node characteristics, but also on the edge type r and the time difference Δt between nodes. _uv It can be described by the following formula:

[0127] α _uv =Softmax(q _v T ×k _u +b _r +w _t ×Δt _uv );

[0128] Among them, b _r It is an edge type bias, w _t It is the time decay factor. Or, in other words, α _uv q represents the message propagation weight (attention coefficient) of neighbor node u to target node v; Softmax is a normalized exponential function that ensures the sum of the weights of all neighbors is 1; _v T k is the transpose of the query vector for the target node v. _u Let b be the key vector of neighbor node u; _r For learnable bias terms related to edge type r, used to distinguish different types of edges (such as causal edges, resource edges); w _t A learnable time decay factor; Δt _uv This represents the absolute value of the time difference between node u and node v.

[0129] This design allows the model to distinguish the influence from different sources. For example, for resource-related edges, if the time difference Δt _uv If the value is relatively small, meaning the performance anomaly has just occurred, then the weight α is relatively small. _uv A larger value indicates that the performance issue has a direct impact on the current event; the impact decreases as the time difference increases. Through multi-layer (e.g., 2-3 layers) message passing, each node can aggregate its multi-hop neighbor information in the causal graph, achieving deep cross-modal fusion.

[0130] Based on this, the fused feature vector of the entire session can be obtained by reading out the features of all nodes in the graph (such as average pooling).

[0131] Another example illustrates the specific working mechanism of the dual-head calibration diagnostic model. It addresses the problem that existing deep learning diagnostic models, when faced with unknown faults not seen in the training set, tend to assign high confidence to known categories, leading to blind overconfidence. This embodiment introduces prototype distance and reconstruction error to construct a quantifiable unknown score, and utilizes quantile statistics to achieve adaptive probability calibration. Exemplarily, this embodiment includes:

[0132] Step S601: Calculate the distance between the fused feature vector and the pre-stored set of known fault prototype vectors, and select the minimum value as the minimum prototype distance.

[0133] In this embodiment, the pre-stored set of known fault prototype vectors (denoted as C) is constructed during the model training phase. For each known fault category k, such as uplink communication interruption, storage medium damage, metering chip malfunction, etc., the mean of the fused feature vectors of all samples belonging to that category in the training set is calculated, and this mean is used as the prototype vector c of that category. _k .

[0134] During the inference phase, when a new fused feature vector z is input, the system calculates the relationship between z and each prototype vector c in set C. _k The Euclidean distance is used to visually reflect the degree to which the current sample deviates from the known fault center in the feature space. The system iterates through all categories and selects the minimum distance as the minimum prototype distance d. _min . d _min The smaller the value, the closer the current sample is to a known fault; d _min The larger the value, the greater the likelihood that the current sample is outside of all known fault distributions and belongs to an unknown fault.

[0135] Step S602: Reconstruct a low-dimensional summary vector from the fused feature vector using a reconstruction network, and calculate the consistency error between the reconstructed vector and the true summary vector obtained based on the original data statistics.

[0136] Specifically, this step introduces an autoencoder-based reconstruction mechanism to further enhance the ability to identify unknown patterns. The reconstruction network is a small, fully connected neural network that maps high-dimensional fused feature vectors back to a low-dimensional statistical summary of the original data. The true summary vector g is obtained directly from the original session data; for example, it could be the count distribution vector of different message types within the session, or the mean vector of key performance indicators.

[0137] Based on this, the reconstructed summary vector output by the reconstruction network is denoted as g. # , # The hat symbol is used. The consistency error e is calculated as the difference between the true summary vector g and the reconstructed summary vector g. # Mean square error (MSE) between: e = ||gg # || 2 If the input samples belong to a known distribution, the model can learn the mapping relationship between its features and statistical summaries well, and the reconstruction error is small; if the input samples belong to an unknown distribution (such as a new type of network attack), this mapping relationship will be broken, resulting in an increase in reconstruction error.

[0138] Step S603: Weighted summation of minimum prototype distance and consistency error to obtain unknown score.

[0139] In this step, in order to comprehensively utilize the distance information in the feature space and the reconstruction information in the statistical space, the system will use the minimum prototype distance d. _min The unknown score u is obtained by linearly combining the consistency error e. The calculation formula can be expressed as:

[0140] u=d _min +λ×e;

[0141] Where λ is the balance coefficient, used to adjust the weight of the two indicators, for example, it can be set to 0.5. The unknown score u is a non-negative real number; the larger its value, the higher the risk that the current sample belongs to an unknown fault. In other words, u is the unknown score of the current sample; d _min λ is the minimum Euclidean distance between the current sample feature vector and the nearest known fault prototype vector; λ is the balance coefficient used to adjust the weights of the distance term and the error term; e is the reconstruction consistency error of the current sample.

[0142] Step S604: Obtain the pre-configured quantile threshold, which is determined based on the unknown score statistical distribution of the training samples.

[0143] In some embodiments, the pre-configured quantile threshold is determined in advance through the following steps:

[0144] Collect historical training samples containing known fault types, and use a dual-head calibration diagnostic model to calculate the unknown score for each historical training sample;

[0145] The probability distribution of unknown scores for all historical training samples is statistically analyzed, and the quantiles corresponding to the preset sensitivity level are calculated. These quantiles are then determined as the pre-configured quantile thresholds.

[0146] It should be understood that unknown scores are absolute values, lacking probabilistic meaning, and their range varies significantly across different application scenarios. Therefore, a benchmark is needed for normalization. This step utilizes a pre-configured quantile threshold obtained through offline calculation. Specifically, after model training, all samples from the validation set are input into the model to calculate a series of unknown scores. The probability distribution of the scores is statistically analyzed, and the quantile corresponding to a preset sensitivity level (e.g., 95%) is selected as the quantile threshold. Thus, in the known samples, 95% of the samples have unknown scores less than this threshold.

[0147] Step S605: Using an activation function that includes quantile thresholds, the currently calculated unknown score is mapped to a calibrated unknown fault probability with a value between 0 and 1.

[0148] In this embodiment, a sigmoid activation function with threshold offset is used to convert the unbounded unknown score u into a probabilistic form. The calibrated unknown fault probability p _unk The calculation formula is as follows:

[0149] p _unk =1 / (1+exp(-γ×(u-θ)));

[0150] Where γ is the temperature coefficient, which can be set to 2.0 to control the steepness of the probability change; θ is the quantile threshold. Or, p _unk The calibrated unknown fault probability ranges from 0 to 1, γ is the temperature coefficient that controls the steepness of the probability transformation curve, u is the currently calculated unknown score, and θ is the pre-configured quantile threshold, obtained based on training set statistics.

[0151] Furthermore, when the unknown score u equals the threshold θ, the probability of the unknown score is 0.5; when u is significantly greater than θ, the probability approaches 1; and when u is significantly less than θ, the probability approaches 0. In other words, when the difference between the two is sufficiently large, a significant change in probability will occur. Specifically, when u−θ>Ъ (Ъ is the preset threshold), the probability approaches 1; and when Ъ (Ъ is the preset threshold), the probability approaches 0.

[0152] Step S606: Scale the known fault probabilities using the calibrated unknown fault probabilities, so that the sum of the scaled known fault probabilities and the sum of the calibrated unknown fault probabilities equals 1.

[0153] After obtaining the unknown failure probability p _unk Then, the system needs to ensure that the output probability vector satisfies the normalization constraint, that is, the sum of all components is 1. Assume that the original probability distribution of the classifier output for n known classes is P. _raw =[p _1 p _2 , ..., p _n ], where ∑(P _raw The system uses a scaling factor (1-p) = 1. _unk ) for P _raw Perform overall compression to obtain the known failure probability p _i '=p _i ×(1-p _unk The output complete fault probability vector is P. _final =[p _1 ', p _2 ', ..., p _n ', p _unk This processing method mathematically integrates open set detection and closed set classification.

[0154] According to one aspect of this application, the known formula for the consistency scaling of failure probability can be expressed as:

[0155] p _i '=p _i ×(1-p _unk );

[0156] Where, p _i ' is the scaled final probability of the i-th known fault type; p _i p represents the original probability of the i-th known fault type output by the known classification head. _unk The above calculation represents the calibrated probability of unknown faults.

[0157] According to another aspect of this application, the known failure probability with a temperature coefficient can be calculated as follows:

[0158] p _k =exp(z _k / τ _temp ) / ∑ _j=1 N exp(z _j / τ _temp );

[0159] Where, p _k z is the predicted probability of the k-th known fault type; _k The raw logits of the k-th category output by the classification header; τ _temp The preset temperature coefficient, for example, 1.5, is used to smooth the probability distribution and prevent the model from overconfident on unknown samples; N is the total number of known fault types, z _j The original logic value (Logits) corresponding to the j-th known fault type.

[0160] According to another aspect of this application, specific numerical calculation examples are provided to illustrate the data flow process from multimodal data input to fault probability output.

[0161] Suppose that at 10:00:00 on May 20, 2024, the electricity information collection terminal experienced an uplink communication timeout failure, which was caused by a disk write delay leading to a momentary CPU overload.

[0162] Accordingly, the system captured the following data: Communication messages: Request (10:00:01, ID=A1), Response (missing). Timeout was 60s. Performance metrics: CPU utilization samples from 10:00:00 to 10:00:05 were [85, 92, 98, 95, 88]. Business logs: A log WARN: Disk write latency high was generated at 10:00:03.

[0163] After extracting the session anchor points, the session window was determined. Following feature encoding, the performance data was encoded into a vector h. _perf The log is encoded as a vector h _log The communication state is encoded as a vector h. _comm .

[0164] Next, the system constructs a cross-modal temporal causal correlation matrix. The causal strength of performance on the logs is calculated, assuming an optimal latency τ = 2s. The time-level correlation score s(t) peaks at 0.9 at t = 10:00:01. The aggregated global strength C... _perf→log =0.85. Similarly, the weight C of the log's impact on communication is calculated. _log→comm =0.78. This forms a strong causal chain: performance → logging → communication.

[0165] Next, feature fusion is performed. The feature vector h of the communication modality... _comm Updated to h _comm '=h _comm +0.78×φ(h _log )+0.85×φ(h _perf ); Due to the integration of high-performance load and disk alert features, h _comm The ' no longer simply indicates a timeout, but includes information about timeouts caused by resource exhaustion.

[0166] Based on this, the dual-head calibration and diagnosis phase begins. The original probability P output by the classification head is known. _raw =[Communication failure = 0.7, Disk failure = 0.2, Others = 0.1]. Minimum prototype distance d _min =0.8 (distance from the prototype of the communication failure). Consistency error e=0.4 (reconstruction effect is acceptable). Unknown score u=0.8+0.5×0.4=1.0.

[0167] Assume a pre-configured quantile threshold θ = 1.5. Since u < θ, the calculated unknown probability p _unk =1 / (1+exp(-2×(1.0-1.5)))≈0.27. Scaling the known probabilities, the communication failure probability = 0.7×(1-0.27)=0.511. The disk failure probability = 0.2×(1-0.27)=0.146. Output probability vector P. _final =[0.511, 0.146, ..., 0.27]. The diagnostic conclusion points to a communication failure, while also indicating a high risk of disk failure, although the unknown risks are within a manageable range.

[0168] This embodiment describes the system architecture supporting this application. It transforms the black-box parameters within the algorithm into white-box evidence visible to the user. Specifically, this includes:

[0169] Step S801: Extract mode pairs with association strength exceeding a preset threshold from the cross-modal association structure.

[0170] After calculating the failure probability, to explain to operations and maintenance personnel why the failure was identified, the system backtracks the cross-modal correlation structure, such as a causal matrix or relationship graph. A causal strength threshold θ is set. _c For example, 0.6. The system iterates through all elements C in the matrix. _ij Filter out C _ij Mode pairs >0.6 (m _i m _j For example, filtering out two strongly correlated modalities: (CPU metrics, error logs) and (error logs, communication messages). That is, m _i m _j These correspond to the source mode i and the target mode j, respectively.

[0171] Step S802: According to the temporal sequence and the magnitude of the correlation, the extracted mode pairs are organized into causal transmission paths that describe the transmission of fault signals between different modes, and the causal transmission paths are output synchronously with the fault probability vector.

[0172] The system constructs a directed causal graph chain based on the selected modal pairs and their corresponding optimal latency τ. For example, it can be organized into a text description or visual topology diagram as follows: An abnormal CPU utilization is detected (t=0s), which propagates over 2.5s to cause a disk write alarm, with a major impact factor of 0.85; after propagation over 1.2s, it causes uplink message acknowledgment loss, with a major impact factor of 0.78. This structured path description is the fault causal propagation path. This path, along with the fault probability vector, is sent to the Human-Machine Interface (HMI) or cloud management platform.

[0173] In terms of system architecture, the method of this invention can run on an embedded operating system (such as Linux or VxWorks) of an electricity information collection terminal. Terminal hardware typically includes a microprocessor (MCU / MPU), memory (Flash / RAM), a metering module, a communication module (HPLC / 4G), and various interfaces. The feature extraction and causal calculation modules of this invention can be lightweightly deployed at the edge of the terminal, utilizing idle computing power for real-time inference; while model training and threshold parameter statistics can be deployed on a cloud main server, periodically sending updated model parameters and thresholds to the terminal via over-the-air (OTA) updates, achieving a collaborative working mode of cloud training and edge inference.

[0174] This embodiment describes the offline training strategy of the model, the specific definition of the loss function, and the parameter optimization method. It illustrates the process of building a functional deep learning model. This embodiment may further include:

[0175] Step S901: Construct a composite loss function that includes classification loss, reconstruction loss, and causal sparsity regularization.

[0176] In this embodiment, to simultaneously optimize fault classification accuracy, unknown pattern detection capability, and the interpretability of causal relationships, the model employs a multi-task joint training strategy. The total loss function L... _total The definition is as follows:

[0177] L _total =L _cls +λ _1 ×L _rec +λ _2 ×L _sparse ;

[0178] Among them, L _cls The cross-entropy loss for the known fault classification head is used to guide the model to accurately identify known fault types; L _rec The reconstruction loss (mean square error, MSE) of the unknown detection head is calculated using the formula ||gg # || 2 This is used to force the model to learn the data distribution characteristics of normal or known failure modes; L _sparse For sparse regularization terms (such as L1 regularization) of cross-modal temporal causal correlation matrices, i.e. L _sparse =∑|C _ij In real-world systems, strong causal relationships between modalities are often sparse. For example, high CPU usage may only affect specific logging and communication. By imposing sparsity constraints, noise can be suppressed, making the learned causal matrix clearer and more interpretable. _1 and λ _2 For hyperparameters, for example, setting λ _1 =0.5, λ _2 =0.01.

[0179] In other words, L _total L represents the total loss function value during model training. _cls The cross-entropy loss for a known fault classification task; λ _1 L represents the weighting coefficients for the reconstruction loss. _rec To reconstruct the mean squared error loss of the network (i.e., ||gg) # || 2 ); λ _2 L represents the weighting coefficients of the sparse regularization term. _sparse The L1 sparse regularization term of the cross-modal causality matrix (i.e., ∑|C _ij |).

[0180] Step S902: Prepare a historical sample set containing known fault labels and divide it into a training set and a validation set.

[0181] During the data preparation phase, historical fault data from the live network is collected. For each data point, its fault type is labeled manually or semi-automatically. Normal samples can also be used as a special fault-free category for training. The dataset is divided into training and validation sets in an 8:2 ratio. Further, data augmentation can be performed on the training data, such as injecting Gaussian noise into the performance metric sequence or performing random word replacements on the log text.

[0182] Step S903: The model parameters are iteratively updated using the backpropagation algorithm, and the unknown score distribution is statistically analyzed on the validation set to determine the quantile threshold.

[0183] The training process can employ the Adam optimizer, or adaptive moment estimation optimizer. The initial learning rate is set to 0.001, and the batch size is set to 32. The model is trained for 50 training epochs. After each training epoch, the model's classification accuracy is evaluated on the validation set. Once model training is complete (loss function converges), the threshold calibration phase begins. All samples from the validation set (including correctly classified samples) are input into the model with frozen parameters, and the unknown score sequence {u} output by the unknown detection head is recorded. _1 u _2 , ..., u _m }, where m is the number of samples in the validation set. Calculate the 95th percentile of the sequence, embed it as a pre-configured quantile threshold, and burn it into the inference model's configuration file for probability calibration during subsequent online diagnosis.

[0184] According to another aspect of this application, another method for diagnosing faults in an electricity consumption information collection terminal is provided, comprising the following steps:

[0185] Optionally, multimodal time-series data acquisition and preprocessing are performed, i.e., heterogeneous, time-series multimodal operational data are collected from the electricity consumption information acquisition terminal; wherein, the multimodal data includes at least:

[0186] Business log sequences, such as instruction execution records and communication session logs;

[0187] Time-series data of performance metrics, such as CPU utilization, memory usage, and disk I / O rate.

[0188] Communication message sequences, such as the type, size, and latency of uplink and downlink messages interacting with the master station;

[0189] System event streams, such as process start / stop events and error reporting events;

[0190] Based on this, the collected data is cleaned, aligned and normalized to form a standardized multimodal time series dataset;

[0191] Optionally, multimodal feature fusion and representation learning can be performed, i.e., a deep learning model can be constructed, which includes parallel feature extraction branches for processing different types of time series data. Accordingly, a one-dimensional convolutional neural network (1D-CNN) branch can be used to extract local features of numerical sequences such as performance metrics, and a long short-term memory network (LSTM) branch can be used to extract long-term contextual dependencies of sequences such as business logs and event streams.

[0192] Furthermore, the high-dimensional feature vectors extracted from each branch are fused to form a unified, comprehensive deep feature vector that represents the terminal's operating status.

[0193] Optionally, end-to-end fault state diagnosis is performed, that is, the end-connector of the deep learning model is a classifier, which takes the fused deep feature vector as input and outputs a fault probability vector.

[0194] Fault probability vector P = [p1, p2, ..., p n p _unk In the diagram, pᵢ represents the probability of the existence of the i-th known fault type, where i = 1, 2, ..., n, and n is the total number of known fault types. _unk This indicates the probability of an unknown or abnormal pattern detected by the model.

[0195] Based on this, the model learns the complex mapping relationship from multimodal raw data to fault state directly through end-to-end training, without the need for manual definition of fault thresholds and rules.

[0196] Optionally, diagnostic results can be output and visualized, that is, the fault probability vector can be output as the diagnostic result and visualized through a human-machine interface to indicate the current health status of the terminal and the specific fault risks.

[0197] In one possible design, p in the failure probability vector _unk This is achieved by introducing unsupervised learning objectives (such as reconstruction error) during model training or by using open set identification algorithms, enabling the model to perceive unknown fault modes.

[0198] In another possible design, the deep learning model employs an attention mechanism to dynamically evaluate the importance of different modal data and data at different time points in the same sequence to the diagnostic results, thereby improving the interpretability and diagnostic accuracy of the model.

[0199] In another possible design, an exemplary scheme for the model training phase is provided.

[0200] Accordingly, a massive amount of historical multimodal operational data from terminals is collected, along with their verified fault labels (including normal states), to form a training set. A multimodal deep learning model is then constructed, specifically including:

[0201] The performance metric sequence (such as CPU utilization) is input into the 1D-CNN branch to extract its local fluctuation patterns;

[0202] Input the business log sequence into the LSTM branch to learn the normal order and logic of its events;

[0203] The feature vectors output by each branch are concatenated or weighted and fused in the fusion layer;

[0204] The fused features are passed through a fully connected classification layer, and the Softmax output layer generates a fault probability vector.

[0205] The model is trained end-to-end using the backpropagation algorithm with the goal of minimizing the cross-entropy loss between the predicted probability and the true label.

[0206] In yet another possible design, alternative implementations of the online diagnostic phase are described, including:

[0207] Real-time acquisition of multimodal time-series data from the target terminal;

[0208] Input the data into the pre-trained multimodal deep learning diagnostic model;

[0209] Each branch within the model automatically extracts and fuses features, and performs comprehensive reasoning.

[0210] The model outputs a fault probability vector, for example: P=[0.02 (APP restart), 0.15 (file system error), 0.80 (uplink communication error), 0.03 (other...), 0.10 (unknown error)];

[0211] The diagnostic results were output and displayed to the operations and maintenance personnel; the results indicated that the terminal was highly likely to have an uplink communication anomaly, accompanied by a risk of file system anomaly, as well as a few unknown anomaly characteristics, which should be given close attention. The diagnostic process is now complete.

[0212] In this application, the embodiments employ a communication session anchor alignment mechanism. By identifying the transaction identifiers of request and response messages and establishing a flexible time window, high-frequency performance metrics (aggregated at multiple granularities), event-driven logs (templated and encoded), and discrete communication interactions are accurately synchronized and merged at the semantic level, solving the problems of business logic fragmentation and context loss caused by traditional physical time sliding windows.

[0213] Furthermore, the embodiment constructs a cross-modal temporal causal association structure, providing two parallel schemes: a causal matrix and a session relationship graph. It calculates the causal strength of latency or constructs a logical topology containing resource / causal edges, and utilizes a causal-guided attention mechanism for dynamic feature fusion. This successfully quantifies and visualizes the transmission path of faults from underlying resources (such as CPU overload) to upper-layer services (such as communication timeouts), breaking down the black box and information silos caused by feature splicing.

[0214] Based on this, the implementation example designed a dual-head calibration and diagnostic architecture. Unknown scores are jointly calculated using the minimum prototype distance and reconstruction error. An adaptive threshold based on statistical quantiles maps the scores to probabilities, and consistent scaling of known classification results is applied. This achieves mathematical normalization of known and unknown fault probabilities, resolving the logical paradox of the model's blind confidence when facing novel faults.

[0215] The optional embodiments of the present invention have been described in detail above. However, the present invention is not limited to the specific details of the above embodiments. Within the scope of the technical concept of the present invention, various equivalent transformations can be made to the technical solution of the present invention, and these equivalent transformations all fall within the protection scope of the present invention.< / num> < / path>

Claims

1. A method for diagnosing faults in an electricity information collection terminal, characterized in that, include: Multimodal time-series data from electricity consumption information collection terminals are acquired, communication session anchors are extracted from them, and semantic alignment and merging of the multimodal time-series data are performed based on these anchors to obtain a standardized session sample sequence. Feature encoding is performed on standardized conversation sample sequences to construct a cross-modal association structure that reflects the temporal causal dependencies between modalities; Based on this, causal-guided feature aggregation and updating are performed on features of different modalities to obtain a fused feature vector containing cross-modal causal transmission information; The fused feature vector is input into the dual-head calibration diagnostic model, which outputs a known fault probability through the known classification head and an unknown score through the unknown detection head. The unknown scores are mapped to calibrated unknown failure probabilities, and the known failure probabilities are then calibrated for consistency to obtain a failure probability vector that satisfies the normalization constraints.

2. The method according to claim 1, characterized in that, Extracting communication session anchors from multimodal time-series data, including: The communication message sequence is parsed from multimodal time-series data to identify request messages and response messages with the same transaction identifier and pair them as session units; Calculate the time interval between adjacent session units. When the time interval exceeds the preset session timeout threshold, determine the session boundary and generate a communication session anchor point containing the session start and end times and the session identifier.

3. The method according to claim 1, characterized in that, Constructing a cross-modal correlation structure that reflects the temporal causal dependencies between modalities, specifically constructing a cross-modal temporal causal correlation matrix, the construction process includes: Define the modality set and the preset time delay search range; Calculate the causal correlation strength between the source mode and the target mode under multiple time delays within the time delay search range; By selecting the causal correlation strength corresponding to the optimal time delay, a cross-modal temporal causal correlation matrix is ​​constructed, in which the elements represent the causal influence weight of the source mode on the target mode under the optimal time delay.

4. The method according to claim 3, characterized in that, Calculate the causal correlation strength between the source mode and the target mode under multiple time delays within the time delay search range, including: For each time delay, extract the feature vector of the source mode at the current time and the feature vector of the target mode after the time delay; The two extracted feature vectors are input into a causal association function containing a learnable time delay bias parameter to calculate the time-level association score. The temporal correlation scores are aggregated and calculated along the time dimension to obtain the global causal correlation strength between the source mode and the target mode under time delay.

5. The method according to claim 3, characterized in that, Causally guided feature aggregation and updating specifically include: The elements in the cross-modal temporal causal correlation matrix are used as weights to weight the features of different modalities; For any target modality, its own feature vector is concatenated or summed with the causal weighted features from other modalities to obtain the updated target modality feature vector; Among them, the causal weighted feature is obtained by multiplying the feature vectors of other modes by their causal influence weights on the target mode after feature transformation.

6. The method according to claim 1, characterized in that, Constructing a cross-modal association structure that reflects the temporal causal dependencies between modalities, specifically by building a session relationship graph. The construction process includes: Using the session corresponding to the communication session anchor point as the unit, the elements in the standardized session sample sequence are mapped to graph nodes. The graph nodes include event nodes that represent business logic, message nodes that represent communication interaction, and performance nodes that represent the running status. Directed edges are constructed based on the semantic and temporal relationships between nodes. The directed edges include at least temporally adjacent edges connecting nodes with adjacent times, session causal edges connecting nodes with request-response or trigger relationships, and resource-related edges connecting performance anomalies and system events.

7. The method according to claim 6, characterized in that, Causally guided feature aggregation and updating specifically involves performing time-series message passing that can be distinguished by relation types, including: For any target node in the session relationship graph, identify its neighboring nodes and the edge types of the connecting edges, and calculate the time difference between the target node and its neighboring nodes; Calculate message propagation weights based on edge type and time difference, and aggregate information of neighboring nodes based on message propagation weights; The feature representation of the target node is updated using the aggregated information to obtain the fused node feature vector.

8. The method according to claim 1, characterized in that, The unknown score is output through the unknown detection head, including: Calculate the distance between the fused feature vector and the pre-stored set of known fault prototype vectors, and select the minimum value as the minimum prototype distance; A reconstruction network is used to reconstruct a low-dimensional summary vector from the fused feature vector, and the consistency error between the reconstructed vector and the true summary vector obtained based on the statistics of the original data is calculated. The unknown score is obtained by weighted summation of minimum prototype distance and consistency error.

9. The method according to claim 1, characterized in that, The unknown scores are mapped to calibrated unknown failure probabilities, and the known failure probabilities are then calibrated for consistency, including: Obtain the pre-configured quantile threshold, which is determined based on the unknown score statistical distribution of the training samples; By using an activation function that includes quantile thresholds, the currently calculated unknown score is mapped to a calibrated unknown fault probability with values ​​between 0 and 1. The known fault probabilities are scaled using the calibrated unknown fault probabilities, so that the sum of the scaled known fault probabilities and the sum of the calibrated unknown fault probabilities equals 1.

10. The method according to claim 1, characterized in that, This method also includes outputting the fault causal propagation path, specifically including: Extract mode pairs whose association strength exceeds a preset threshold from the cross-modal association structure; Based on the temporal sequence and the strength of the correlation, the extracted mode pairs are organized into causal transmission paths that describe the transmission of fault signals between different modes, and the causal transmission paths are output synchronously with the fault probability vector.

Images