A progressive knowledge-injected early warning system for utility tunnels and its model construction method

Abstract

This invention belongs to the field of artificial intelligence technology and discloses a progressive knowledge-injected early warning system for utility tunnels and a model construction method. The method includes: synchronizing raw sensor time-series data, raw operation and maintenance logs, and a knowledge graph of utility tunnel equipment; extracting a sensor intermediate layer feature map set from the sensor data using a one-dimensional convolutional neural network model; encoding the operation and maintenance log text into a log semantic embedding vector set using a sentence vector representation model; performing a feature-level affine transformation on each channel of the sensor intermediate layer feature map set using the log semantic embedding vector set as input, and concatenating it with a knowledge graph feature set from the knowledge graph to form a fused multimodal feature vector set; and feeding this feature vector set into a classifier to produce a probabilistic early warning classification result set. This invention, for the first time, endows predictive maintenance systems with the ability to understand human experience and use it to resolve the ambiguity of physical signals.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and more specifically, to a progressive knowledge-injected early warning system for utility tunnels and a model construction method therefor. Background Technology

[0002] In the field of critical infrastructure operation and maintenance, data-driven predictive maintenance has evolved from traditional passive repair and periodic prevention strategies into a core strategy for improving system reliability and operational efficiency. The cornerstone of this advanced approach lies in the analysis of massive amounts of structured data, particularly physical measurement data collected from various sensor networks in the form of high-frequency time series. By modeling this data, the system can monitor the physical health status of equipment and predict potential failures. However, this field faces a long-standing and pervasive challenge: relying solely on quantitative physical signals often fails to provide a comprehensive understanding of complex failure mechanisms involving multiple factors or requiring deep domain knowledge for interpretation. This limitation stems from the lack of contextual description of the deep causal relationships behind equipment operating states in structured data itself. Therefore, effectively integrating heterogeneous data from different sources and in different formats to build a more comprehensive and context-aware cognitive model of equipment status is one of the key bottlenecks in the current development of predictive maintenance technology.

[0003] In view of this, the present invention proposes a progressive knowledge-injected early warning system for utility tunnels and a model construction method to solve the above problems. Summary of the Invention

[0004] To overcome the aforementioned shortcomings of the existing technology and achieve the above objectives, the present invention provides the following technical solution: a method for constructing a pipe gallery early warning model with progressive knowledge injection, comprising:

[0005] Step F1: Based on the timestamp of the original operation and maintenance log and according to the time window configuration, the original operation and maintenance log is aligned, windowed and feature extracted with the original sensor time series data and the knowledge graph of the pipe gallery equipment, respectively, to obtain the aligned log text set, the aligned sensor sequence set and the associated knowledge graph feature set;

[0006] Step F2: Based on the specified sentence vector representation model identifier, select the corresponding sentence vector representation model and perform batch encoding on the aligned log text set to obtain the log semantic embedding vector set;

[0007] Step F3: Using a one-dimensional convolutional neural network defined by the parameters of the one-dimensional convolutional neural network architecture, batch feature extraction is performed on the aligned sensor sequence set to obtain the sensor intermediate layer feature map set.

[0008] Step F4: Input the log semantic embedding vector set into the neural network defined by the feature-level linear modulation generator architecture parameters to generate a scaling parameter tensor γ and an offset parameter tensor β for each feature map in the sensor intermediate layer feature map set, and obtain the feature-level linear modulation parameter set (γ, β);

[0009] Step F5: For each feature map in the sensor intermediate layer feature map set, apply the corresponding parameters in the feature-level linear modulation parameter set (γ, β) to perform a feature-level affine transformation, and then concatenate the transformed result with the corresponding features in the associated knowledge graph feature set to obtain the fused multimodal feature vector set.

[0010] Step F6: Input the fused multimodal feature vector set into the classifier defined by the classification head architecture parameters to obtain the final warning classification result set;

[0011] Step F7: Apply the maximum value decision rule and determine and output the final warning level from the warning classification result set according to the warning level sequence list.

[0012] Furthermore, the implementation method of step F4 includes:

[0013] Step F4F1 sets the batch size to the number of vectors contained in the log semantic embedding vector set;

[0014] Step F4F2: Obtain the number of channels in a single sensor intermediate layer feature map in the sensor intermediate layer feature map set, denoted as C;

[0015] Step F4F3: Based on the feature-level linear modulation generator architecture parameters, construct a multilayer perceptron model with the dimension of a single log semantic embedding vector as the input dimension and the output dimension as 2×C, to obtain the feature-level linear modulation generator network.

[0016] Step F4F4: Input the log semantic embedding vector set into the feature-level linear modulation generator network, perform batch forward propagation, and obtain a two-dimensional feature-level linear modulation raw output tensor, wherein the size of the first dimension of the tensor is the batch size, and the size of the second dimension is 2×C.

[0017] Steps F4 and F5 involve splitting the original output tensor of the feature-level linear modulation in the last dimension to obtain the scaling parameter tensor γ and the offset parameter tensor β. The scaling parameter tensor and the offset parameter tensor are two-dimensional tensors with the size of the batch size in the first dimension and the size of C in the second dimension.

[0018] In steps F4 and F6, the scaling parameter tensor γ and the offset parameter tensor β are encapsulated into a single logical unit to obtain the feature-level linear modulation parameter set (γ, β).

[0019] Furthermore, the implementation method of step F4F3 includes:

[0020] Step F4F3F1: Read the architecture configuration parameters for defining the multilayer perceptron structure from the feature-level linear modulation generator architecture parameter dictionary. The architecture configuration parameters include at least a list of the number of hidden layer neurons and activation functions.

[0021] Steps F4F3F2 involve constructing the feature-level linear modulation generator network, which is a multilayer perceptron consisting of an input layer, one or more hidden layers, and an output layer connected in sequence. Specifically: the number of neurons in the input layer is equal to the dimension of a single log semantic embedding vector; the number of layers and the number of neurons in each of the one or more hidden layers are determined by a list of the number of neurons in the hidden layers, and the hidden layers use the activation function; the number of neurons in the output layer is equal to twice the number of channels.

[0022] Furthermore, the implementation method of step F5 includes:

[0023] Step F5F1: Unpack the feature-level linear modulation parameter set (γ, β) to obtain the scaling parameter tensor γ and the offset parameter tensor β;

[0024] Step F5F2: For each feature map in the sensor intermediate layer feature map set, apply the corresponding elements in the scaling parameter tensor γ and the offset parameter tensor β to perform a feature-level affine transformation to obtain the modulated feature map set.

[0025] Step F5F3: Apply global average pooling operation in the time dimension to each feature map in the modulated feature map set to compress each feature map from a two-dimensional tensor into a one-dimensional vector, and obtain the modulated temporal feature vector set.

[0026] Step F5F4 involves concatenating the modulated temporal feature vector set with the associated knowledge graph feature set one by one along the feature dimension to obtain the final fused multimodal feature vector set.

[0027] Furthermore, the implementation method of step F5F2 includes:

[0028] Step F5F2F1: Adjust the shape of the scaling parameter tensor and the offset parameter tensor, and expand the two two-dimensional tensors into three-dimensional tensors respectively. The newly added dimension is used to align with the time dimension of the sensor intermediate layer feature map during computation.

[0029] Step F5F2F2 involves performing element-wise multiplication of the sensor intermediate layer feature map set with the adjusted scaling parameter tensor to obtain the product tensor.

[0030] Steps F5F2F3 involve performing element-wise addition operations on the product tensor and the adjusted offset parameter tensor to obtain the final modulated feature map set.

[0031] Furthermore, the implementation method of step F6 includes:

[0032] Step F6F1: Based on the classification head architecture parameters, construct a classifier network consisting of multiple fully connected layers and a normalized exponential activation function output layer;

[0033] Step F6F2 involves inputting the fused multimodal feature vector set into the classifier network and performing batch forward propagation to obtain a set of early warning classification results representing the probability distribution of each early warning category.

[0034] Furthermore, the implementation method of step F7 includes:

[0035] Step F7F1: Create an initially empty list to store the highest probability prediction for all windows in this batch, and name it the "Prediction Level List for This Batch".

[0036] Step F7F2: For each prediction result dictionary in the early warning classification result set, find the early warning level with the highest probability value and add the found early warning level to the prediction level list for this batch.

[0037] Step F7F3: Temporarily save the last level in the warning level sequence list as the current highest level;

[0038] Step F7F4: Iterate through each candidate level in the warning level sequence list. If a candidate level exists in the prediction level list for this batch, set the candidate level as the final warning level and terminate the loop immediately.

[0039] In step F7F5, if the final warning level is still not set after traversing all candidate levels in the warning level sequence table, then the current highest level is assigned to the final warning level.

[0040] A progressive knowledge-injected utility tunnel early warning system, implementing the aforementioned progressive knowledge-injected utility tunnel early warning model construction method, the system comprising:

[0041] The alignment module, based on the timestamps of the original operation and maintenance logs and according to the time window configuration, aligns, windowes, and extracts features from the original operation and maintenance logs, original sensor time-series data, and knowledge graph of the pipe gallery equipment, respectively, to obtain the aligned log text set, the aligned sensor sequence set, and the associated knowledge graph feature set;

[0042] The log semantic module selects the corresponding sentence vector representation model based on the specified sentence vector representation model identifier, performs batch encoding on the aligned log text set, and obtains the log semantic embedding vector set.

[0043] The sensing feature module uses a one-dimensional convolutional neural network defined by the architecture parameters of a one-dimensional convolutional neural network to perform batch feature extraction on the aligned sensor sequence set to obtain the sensor intermediate layer feature map set.

[0044] The parameter module takes the log semantic embedding vector set as input to the neural network defined by the feature-level linear modulation generator architecture parameters, and generates a scaling parameter tensor γ and an offset parameter tensor β for each feature map in the sensor intermediate layer feature map set, which together obtain the feature-level linear modulation parameter set (γ, β);

[0045] The feature stitching module performs a feature-level affine transformation on each feature map in the sensor intermediate layer feature map set using the corresponding parameters in the feature-level linear modulation parameter set (γ, β), and stitches the transformed result with the corresponding features in the associated knowledge graph feature set to obtain a fused multimodal feature vector set.

[0046] The classification module inputs the fused multimodal feature vector set into the classifier defined by the classification head architecture parameters to obtain the final warning classification result set;

[0047] The early warning module applies the maximum value decision rule and determines and outputs the final early warning level from the early warning classification result set according to the early warning level sequence list.

[0048] The beneficial effects of the progressive knowledge-injected pipe gallery early warning system and model construction method of this invention are as follows:

[0049] The core feature of this solution lies in using a set of log semantic embedding vectors extracted from operation and maintenance logs to drive a feature-level linear modulation generator network. This network dynamically generates a dedicated scaling parameter tensor γ and offset parameter tensor β for each channel of the sensor intermediate layer feature map. This feature-level affine transformation allows textual semantics, imbued with human expert experience, to directly and proactively intervene in the processing of physical signal features. The direct result is that the model gains the ability to distinguish between two operating conditions: abnormal fluctuations caused by real fault precursors and normal fluctuations caused by recorded, benign operation and maintenance, even though these two conditions may appear very similar at the signal level.

[0050] Furthermore, after semantically modulating the sensor features, this solution further concatenates them with the feature set of the associated knowledge graph extracted from the knowledge graph of the utility tunnel equipment, forming a more comprehensive basis for decision-making and thus improving the accuracy of early warnings. This feature integrates three heterogeneous information types: dynamic temporal behavior, deep semantic context, and static background attributes. The result is that when making decisions, the classifier not only knows "how the signal changes" and "what happened," but also "which specific object the event occurred on and its inherent attributes," thereby making the basis for early warning judgments more sufficient and the results more reliable.

[0051] In summary, this technical solution, through the combination of the aforementioned features, achieves a deep fusion and disambiguation of human experience with machine signal analysis capabilities at the mechanistic level. It fundamentally solves the problem of excessively high false alarm rates caused by missing context, significantly reduces "alarm fatigue" among maintenance personnel, increases their trust in the automated early warning system, and ultimately unlocks the ability to discover novel, hidden, and highly context-dependent early fault modes that are inaccessible by traditional methods. Attached Figure Description

[0052] Figure 1 A schematic diagram of the method flow for constructing a pipe gallery early warning model based on progressive knowledge injection, as described in this invention;

[0053] Figure 2 A schematic diagram of a module for a progressive knowledge-injected pipe gallery early warning system according to the present invention;

[0054] Figure 3 This is a schematic diagram illustrating an application scenario of the progressive knowledge-injected early warning model construction method for utility tunnels according to the present invention. Detailed Implementation

[0055] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. 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 are within the scope of protection of the present invention.

[0056] Example 1

[0057] See Figure 1 The method for constructing a pipe gallery early warning model with progressive knowledge injection described in this embodiment includes steps F1 to F7.

[0058] This embodiment will elaborate on the end-to-end deterministic computation process required to generate the final warning level. Logically, this process can be divided into four core stages. The first stage is data preparation and alignment, which aims to construct time-synchronized multimodal data samples from multiple heterogeneous data sources around each operation and maintenance log event. The second stage is parallel feature extraction. In this stage, unstructured raw operation and maintenance logs are transformed into numerical vectors containing deep semantics, while structured raw sensor time-series data are transformed into feature maps containing key time-series patterns. The third stage is the core innovation of this solution: through a Feature-wise Linear Modulation (FiLM) mechanism, the textual semantics are conditionally and dynamically adjusted in relation to the sensor feature processing. The final stage is decision generation, where a classifier interprets the deeply fused features produced in the preceding steps and ultimately outputs a warning level with context-aware capabilities.

[0059] Step F1: Based on the timestamp of the original operation and maintenance log and according to the time window configuration, the original operation and maintenance log is aligned, windowed and feature extracted with the original sensor time series data and the knowledge graph of the pipe gallery equipment, respectively, to obtain the aligned log text set, the aligned sensor sequence set and the associated knowledge graph feature set.

[0060] Step F1 is the cornerstone of the entire multimodal fusion process, and its core challenge lies in handling the time synchronization problem between data from different sources. Operational logs are typically sparse, event-based records, while sensor data are dense, periodically sampled time-series signals. Aligning both on a unified timeline is a prerequisite for establishing contextual relationships.

[0061] A windowing approach, anchored by log timestamps, is employed to capture the dynamic physical signals directly related to operational events, including potential pre-event symptoms and the system's response after the event. Unlike simple equal-interval time slicing, this method organizes data around domain events, making it more physically meaningful.

[0062] During alignment, potential clock inconsistencies and offsets must be addressed. Errors caused by time zones or daylight saving time are minimized by forcing all input source timestamps to conform to the UTC standard with time zone information. For more subtle system clock drifts, subsequent models are expected to learn a certain tolerance.

[0063] like Figure 3As shown, the raw sensor time-series data originates from various sensors installed at physical measurement points on critical infrastructure, such as piezoelectric accelerometers, thermocouples, and pressure transmitters. The raw sensor output is typically an analog voltage or current signal, which is converted from analog to digital (ADC) at a well-defined sampling frequency using a dedicated data acquisition (DAQ) module. This conversion quantizes the physical measurement value into a floating-point number expressed in International Standard Units (ISUs). Each data sampling point must be accompanied by a UTC timestamp conforming to ISO 8601, synchronized with a standard time source via the Network Time Protocol (NTP), to ensure time comparability across data sources.

[0064] The original operation and maintenance logs originate from qualified frontline operation and maintenance engineers. These logs are manually entered manually within a standardized electronic work order or operation and maintenance management system after completing specific maintenance, inspection, or troubleshooting tasks. While the log text fields are in natural language, the entry process typically follows internal operating procedures, requiring objective and concise descriptions of observed phenomena, implemented measures, and results. The log timestamp is a mandatory field filled in by the engineer, representing the actual time the recorded event occurred, not the server time of the data entry system. This timestamp must comply with the ISO 8601 standard.

[0065] The knowledge graph for utility tunnel equipment is built based on the W3C's Resource Description Framework (RDF) standard. Entities in the graph, such as equipment, sensors, and pipeline segments, along with their static attributes like manufacturer, installation date, and material, are extracted from authoritative engineering data sources, including structured equipment ledger databases, P&ID engineering drawings, and unstructured equipment operation and maintenance manuals, through a semi-automated knowledge extraction process. Relationships between entities, such as "installed at" and "powered by," are linked according to a predefined ontology model conforming to industry standards. All entities, attributes, and relationships are ultimately encoded into a series of RDF triples (subject-verb-object), forming a machine-readable knowledge base.

[0066] The time window configuration defines a hyperparameter dictionary of data alignment ranges. This dictionary contains a 'before' key for defining the duration of forward look-back and a 'after' key for defining the duration of backward look-back. The integer values ​​corresponding to these keys are not obtained through physical measurements, but rather determined through a one-time, systematic statistical analysis of a large amount of historical fault and operational event data, such as performing Failure Mode and Effects Analysis (FMEA). This analysis aims to quantify the duration of typical physical precursor signals before a failure event occurs, and the time required for the system response to recover to a steady state after the event. The duration of these statistically derived averages or specific quantiles is used as the setpoint for the time window configuration.

[0067] By extracting device entities from logs and associating them with a knowledge graph, a third modality of information—static background knowledge—is introduced into the final progressively knowledge-injected utility tunnel early warning model. This enables the model to not only know "what happened" and "how the signal changed," but also "which specific object the event occurred on and its inherent attributes," thus forming a more complete basis for decision-making.

[0068] The implementation method of step F1 includes: Step F1F1, creating three initially empty sets to store log text, sensor sequence fragments, and knowledge graph features, respectively. For each currently processed log in the original operation and maintenance log, steps F1F2 to F1F7 are executed cyclically: Step F1F2, extracting the timestamp from the currently processed log as an event anchor and log text. Step F1F3, based on the event anchor and time window configuration, filtering all data points within the corresponding time range in the original sensor time series data to form a sensor data sequence fragment. Step F1F4, using Named Entity Recognition (NER) technology to extract the device ID from the log text, and using the device ID to query and extract relevant static attributes of the equipment from the knowledge graph of the utility tunnel equipment to obtain static features of the knowledge graph. Step F1F5, adding the extracted log text to the log text set. Step F1F6, adding the formed sensor data sequence fragment to the sensor sequence fragment set. Step F1F7, adding the obtained static features of the knowledge graph to the knowledge graph feature set. Step F1F8: Name the final log text set as the aligned log text set. Step F1F9: Name the final sensor sequence fragment set as the aligned sensor sequence set. Step F1F10: Name the final knowledge graph feature set as the associated knowledge graph feature set.

[0069] The aligned log text set generated in step F1 is a list containing multiple UTF-8 encoded strings. In the logical chain, the core role of the aligned log text set is as a collection of raw textual evidence, precisely timestamped, related to the event being analyzed. This aligned log text set will be used as direct input to subsequent natural language processing steps, where it is cleaned and encoded into a numerical representation in step F2.

[0070] The aligned sensor sequence set generated in step F1 is a list of multiple two-dimensional numerical arrays, where each array has dimensions of (time step, number of sensor channels). In the logical chain, the core role of the aligned sensor sequence set is as a quantitative record of the physical state evolution, strictly time-synchronized with each log event. The aligned sensor sequence set will be used as direct input to subsequent time series analysis procedures, and in step F3, it is fed into a feature extraction network to identify key dynamic patterns.

[0071] The associated knowledge graph feature set generated in step F1 is a list of multiple one-dimensional numerical vectors, each representing a static attribute of a device. In the logical chain, the core function of the associated knowledge graph feature set is to provide static, invariant background knowledge for each event, such as device type, manufacturer, or design parameters. The associated knowledge graph feature set will be temporarily held and concatenated with dynamically modulated temporal features in step F5 to form the final, most comprehensive multimodal feature set.

[0072] The implementation method of step F1F3 includes: Step F1F3F1, extracting the integer values ​​corresponding to the keys 'before' and 'after' from the time window configuration dictionary. Step F1F3F2, calculating the start and end times of the time window based on the event anchor timestamp and the extracted forward and backward durations. Step F1F3F3, filtering out all rows in the original sensor time series data whose timestamp column values ​​fall within the calculated time window range. Step F1F3F4, outputting the filtered set of data rows as a sensor data sequence fragment.

[0073] The implementation method of step F1F4 includes: Step F1F4F1, inputting the log text into a pre-trained Named Entity Recognition (NER) model for the operation and maintenance domain. Step F1F4F2, parsing and extracting entity strings labeled with device IDs from the output of the NER model. Step F1F4F3, using the extracted device IDs, constructing a standard knowledge graph query language (SPARQL) query or equivalent API request for the knowledge graph of utility tunnel equipment to obtain all static attributes corresponding to the device ID. Step F1F4F4, executing the query or request, and combining the returned key-value pairs of attributes into static features of the knowledge graph.

[0074] To enable subsequent machine learning models to understand the contextual information contained in aligned log text sets, unstructured natural language text must be converted into a structured, high-dimensional numerical format. This process is called semantic embedding, and its goal is to generate a feature representation where the proximity of vectors in geometric space reflects the semantic similarity of the original text. This method can capture much richer and more nuanced semantic connotations than traditional keyword matching or bag-of-words models, and is a prerequisite for achieving deep semantic understanding.

[0075] Step F2: Based on the specified sentence vector representation model identifier, select the corresponding sentence vector representation model and perform batch encoding on the aligned log text set to obtain the log semantic embedding vector set.

[0076] Step F2 aims to transform unstructured operational logs into a dense numerical representation that can be processed by a machine learning model. This function is accomplished by a "sentence vector representation model." In this embodiment, the Sentence-BERT (SBERT) model is specifically chosen. SBERT was chosen instead of the original BERT model because it offers superior performance and higher computational efficiency in semantic similarity search and sentence embedding generation tasks. SBERT is fine-tuned through its Siamese network structure to specifically optimize the generation of semantically comparable sentence vectors, which is precisely what this solution requires: a numerical representation capable of distinguishing subtle semantic differences such as "pump startup anomaly" and "routine pump maintenance."

[0077] Preprocessing log text is a crucial step in ensuring embedding quality. Operational logs typically contain a large amount of noise, non-standard abbreviations, and domain-specific terminology; directly inputting them into a general language model can lead to semantic comprehension biases. Therefore, a standardized cleaning process is essential.

[0078] A sentence vector representation model identifier is a string-formatted resource locator, rather than a parameter obtained through measurement or computation. The sentence vector representation model identifier uniquely specifies the name of a pre-trained language model hosted in a large public model repository. The selection of this identifier is based on a systematic model evaluation process: multiple candidate pre-trained models are benchmarked on a labeled validation dataset relevant to the target application domain, and the identifier corresponding to the model that performs best on the downstream task is ultimately selected.

[0079] To obtain a fixed-size sentence vector from BERT's variable-length output, this scheme employs the mean pooling strategy, which is recommended as the default strategy in the original SBERT paper. The mean pooling strategy generates a comprehensive vector representing the semantics of the entire sentence by averaging the embedding vectors of all output tokens. Practice has shown that the results obtained by applying the mean pooling strategy are superior to those obtained by using only [CLS] tokens or max pooling.

[0080] A core engineering assumption is that the SBERT encoder used has been fine-tuned or domain-adaptive trained on corpora from operations or related industrial sectors. General language models tend to degrade in performance when dealing with highly specialized technical texts, while domain adaptation allows the model to better understand the precise meaning of specific terms, such as "surge" or "wheel turn," thereby generating higher-quality log semantic embedding vectors.

[0081] The implementation method of step F2 includes: Step F2F1, performing a series of standardized preprocessing operations on each log text in the aligned log text set, including converting to lowercase, removing embedded timestamps and irrelevant special characters from the text, and replacing proprietary abbreviations in the operation and maintenance domain with full names based on a predefined dictionary, to obtain a cleaned log text set. Step F2F2, loading a pre-trained Siamese BERT network model using sentence vector representation model identifiers to obtain the SBERT encoder. Step F2F3, inputting the cleaned log text set into the SBERT encoder, applying a mean pooling strategy to the word embedding sequence output by the model to generate a fixed-dimensional embedding vector for each log, and summing all vectors into a log semantic embedding vector set.

[0082] The log semantic embedding vector set generated in step F2 is a shape of The embedding dimension is a two-dimensional floating-point tensor, where the embedding dimension is a fixed integer determined by the selected sentence vector representation model identifier, such as 768. In the logical chain, the core role of the log semantic embedding vector set is as a numerical representation of the original log text, containing deep semantic information. The log semantic embedding vector set will serve as a key input to the feature-level linear modulation generator network in the subsequent step F4, used to generate modulation parameters that can dynamically adjust sensor features based on log semantics.

[0083] The implementation method of step F2F1 includes: Step F2F1F1, creating an initially empty list to store the cleaned log text. For each log text to be processed in the aligned log text set, repeat steps F2F1F2 to F2F1F5: Step F2F1F2, converting all log text strings to lowercase. Step F2F1F3, using predefined regular expressions, searching and removing all substrings conforming to date and time formats and other irrelevant special characters from the text obtained in the previous step. Step F2F1F4, iterating through a predefined dictionary of operational terminology abbreviations, replacing the keys appearing in the text obtained in the previous step with their corresponding values, obtaining the cleaned log text. Step F2F1F5, adding the cleaned log text to the list of cleaned log texts. Step F2F1F6, naming the final list of cleaned log texts the "Cleaned Log Text Set".

[0084] The raw time-series data contained in the aligned sensor sequence sets contains complex, non-linear dynamic patterns that are not always obvious to human observers. Therefore, the logical intent of subsequent steps is to leverage a deep learning architecture specifically designed for sequential data—a one-dimensional convolutional neural network (1D-CNN)—as an automated, hierarchical feature extractor. The network aims to learn and identify physically meaningful key morphological features in the signal layer by layer, such as transient impulses, periodic oscillations, or slow trend drifts, transforming these raw signals into a more abstract, information-dense feature representation.

[0085] Step F3: Using a one-dimensional convolutional neural network defined by the one-dimensional convolutional neural network architecture parameters, batch feature extraction is performed on the aligned sensor sequence set to obtain the sensor intermediate layer feature map set.

[0086] Step F3 is responsible for processing high-frequency sensor time-series data. A one-dimensional convolutional neural network (CNN) is chosen as the feature extractor because it has the ability to efficiently capture local patterns and the advantage of parallel computing when processing fixed-length sequence data. The convolutional kernels of the 1D-CNN slide along the time dimension, which can effectively learn key morphological features in the signal, such as impulses, oscillations, and trend drifts, which are crucial for fault diagnosis.

[0087] A one-dimensional convolutional neural network architecture parameter is a dictionary of hyperparameters that defines the neural network structure. Its key-value pairs, such as the number of filters in convolutional layers, kernel size, and activation function type, are not determined by physical measurements, but rather through a systematic, automated hyperparameter optimization process. This process typically employs algorithms such as grid search or Bayesian optimization, on an independent validation dataset, to iteratively search for and determine the optimal architecture configuration with the objective of maximizing a predefined model performance metric, such as the F1 score or the area under the precision-recall curve.

[0088] Compared to recurrent neural networks, 1D-CNN has lower computational complexity when processing fixed window sequences in this scheme, and it does not have the problems of gradient vanishing or exploding, making it more suitable as a low-level feature extractor.

[0089] The key to step F3 is that the output is a sensor intermediate layer feature map, rather than the final feature vector after global pooling or flattening. This intermediate layer feature map is a multi-channel two-dimensional tensor (shape: (time step, number of channels)) that retains rich temporal feature information extracted at different levels. Each channel can be understood as a response to a specific pattern of the input signal, such as the energy within a certain frequency range, the signal gradient, etc. Providing a "canvas" for fine-tuning subsequent FiLM modulation operations is the core reason for retaining this multi-channel structure.

[0090] The implementation method of step F3 includes: Step F3F1, constructing a one-dimensional convolutional neural network (1D-CNN) consisting of multiple stacked one-dimensional convolutional layers and max-pooling layers based on the parameters of the one-dimensional convolutional neural network architecture, to obtain the sensor feature extraction network. Step F3F2, feeding the aligned sensor sequence set as input into the sensor feature extraction network for batch forward propagation, but not calculating to the final output. Step F3F3, after the last convolutional block of the sensor feature extraction network and before the global pooling layer, extracting the network activation values ​​corresponding to each sequence, and summing all activation values ​​to obtain the sensor intermediate layer feature map set.

[0091] The sensor intermediate layer feature map generated in step F3 is a shape of The three-dimensional floating-point tensor. In the logical chain, the core role of the sensor intermediate layer feature map set is to serve as a highly condensed abstract representation of the original sensor time-series data, refined by a deep learning model; each slice in the channel dimension represents a specific time-series pattern that the network has learned to recognize. The sensor intermediate layer feature map set will act as the modulated "subject," receiving an affine transformation from the FiLM mechanism in step F5 to achieve context-adaptive adjustment of the features.

[0092] The implementation method of step F3F1 includes: Step F3F1F1, reading the parameter set used to define each convolutional layer from the one-dimensional convolutional neural network architecture parameter dictionary. This parameter set includes at least: the number of filters, the kernel size, the stride, the padding method, and the activation function. Step F3F1F2, based on the read parameters, instantiating one or more one-dimensional convolutional layers and max-pooling layers using the API of the deep learning framework. Step F3F1F3, stacking all the instantiated layers into a sequence model in the order defined in the parameters to obtain the sensor feature extraction network.

[0093] The following steps, F4 and F5, together constitute the core innovative mechanism of this scheme. Their logical intent is to establish a transformation bridge, converting the abstract semantic information contained in the log semantic embedding vector set into a set of concrete, executable numerical "instructions." These instructions will exist in the form of scaling parameter tensors and offset parameter tensors, and will be used to directly intervene in and reshape the feature processing flow of sensor data. The purpose of this step is to construct a lightweight neural network specifically designed to generate these "instructions."

[0094] Step F4: Input the log semantic embedding vector set into the neural network defined by the feature-level linear modulation generator architecture parameters to generate a scaling parameter tensor γ and an offset parameter tensor β for each feature map in the sensor intermediate layer feature map set, and obtain the feature-level linear modulation parameter set (γ, β).

[0095] Step F4 is a crucial bridge connecting textual semantics and temporal features, embodying the core innovation of the solution. Its purpose is to transform the abstract semantic information extracted from the logs into modulated signals that can directly provide numerical and precise control over the sensor data processing flow.

[0096] The feature-level linear modulation generator architecture parameters are a dictionary of hyperparameters that define the structure of a multilayer perceptron. Similar to the architecture parameters of a one-dimensional convolutional neural network, its internal structural definitions, such as the hidden_layers list and the activation function type, are determined by performing a systematic hyperparameter optimization algorithm, such as grid search or Bayesian optimization, on a validation set, with the goal of finding the MLP configuration that most effectively maps the log semantic embedding vector set to the optimal modulation parameters.

[0097] The FiLM generator itself is typically implemented using a lightweight feedforward neural network. Its structure is relatively simple because it performs the mapping task rather than complex feature extraction. Its input is a high-dimensional log semantic embedding vector, and its output is a pair of modulation parameters (γ, β) tailored to each channel of the sensor feature map.

[0098] Step F4 strictly follows the Feature-wise Linear Modulation (FiLM) framework proposed by Perez et al. The role of the FiLM generator is to predict the parameters of the FiLM layer based on external conditional information, in this case, log semantics. The dimension of the output vector is precisely set to 2×C, where C is the number of channels in the feature map to be modulated. This ensures that each feature channel receives its own scaling factor γ and offset β, thereby achieving fine-grained control at the feature level.

[0099] Step F4 is a direct application of the Feature-Level Linear Modulation (FiLM) framework, first proposed and validated by Perez et al. in their research on visual reasoning. In its original application scenario, FiLM was shown to efficiently utilize information from one modality as a condition to dynamically and adaptively modulate the feature processing of another modality. The innovation of this approach lies in recognizing the significant application potential of this general conditionalization mechanism in predictive maintenance and successfully transferring concepts from the original framework: maintenance log text plays the role of the "problem," while sensor time-series data plays the role of the "image." The rationality and feasibility of this cross-domain application are built upon the solid theoretical foundation of FiLM as a general modulation module.

[0100] The implementation method of step F4 includes: Step F4F1, setting the batch size to the number of vectors contained in the log semantic embedding vector set. Step F4F2, obtaining the number of channels of a single sensor intermediate layer feature map in the sensor intermediate layer feature map set, denoted as C. Step F4F3, based on the feature-level linear modulation generator architecture parameters, constructing a multilayer perceptron model with the dimension of a single log semantic embedding vector as the input dimension and the output dimension as 2×C, to obtain the feature-level linear modulation generator network. Step F4F4, inputting the log semantic embedding vector set into the feature-level linear modulation generator network, performing batch forward propagation, and obtaining a two-dimensional feature-level linear modulation raw output tensor, wherein the size of the first dimension of the tensor is the batch size, and the size of the second dimension is 2×C. Step F4F5, splitting the feature-level linear modulation raw output tensor on the last dimension to obtain a scaling parameter tensor γ and an offset parameter tensor β, wherein the scaling parameter tensor and the offset parameter tensor are two-dimensional tensors with the first dimension being the batch size and the second dimension being C. In steps F4 and F6, the scaling parameter tensor γ and the offset parameter tensor β are encapsulated into a single logical unit to obtain the feature-level linear modulation parameter set (γ, β).

[0101] The feature-level linear modulation parameter set (γ, β) generated in step F4 is a logical tuple containing two elements of shape γ. A two-dimensional floating-point tensor. In the logic chain, the core role of the feature-level linear modulation parameter set (γ, β) is not data features, but rather "meta-parameters" or "instruction sets" dynamically generated by the model to guide the next operation. They will serve as the specific values ​​required to perform feature-level affine transformations, and in step F5, they will be used to perform fine-grained, independent linear adjustments to each feature channel of the sensor intermediate layer feature map.

[0102] The implementation of step F4F3 includes: Step F4F3F1, reading the parameter set used to define the multilayer perceptron (MLP) structure from the feature-level linear modulation generator architecture parameter dictionary. This parameter set includes at least: a list of hidden layer neurons and activation functions. Step F4F3F2, based on the parameters read in the previous step and combined with the input and output dimension information obtained from the calling context, instantiating a multilayer perceptron (MLP) using the deep learning framework's API, and defining the instantiated multilayer perceptron (MLP) as a feature-level linear modulation generator network.

[0103] Step F5: For each feature map in the sensor intermediate layer feature map set, apply the corresponding parameters in the feature-level linear modulation parameter set (γ, β) to perform a feature-level affine transformation, and then concatenate the transformed result with the corresponding features in the associated knowledge graph feature set to obtain the fused multimodal feature vector set.

[0104] Step F5 is the core execution point of the innovation, realizing a paradigm shift from "passive feature splicing" to "active conditional processing". Unlike traditional methods that treat log features and sensor features as two independent inputs for later fusion, this solution uses the FiLM mechanism to allow log information to directly and actively intervene in and reshape the sensor feature extraction process.

[0105] Feature-level affine transformation is the core operation of FiLM. The γ parameter acts as a dynamic gating mechanism, amplifying or diminishing the importance of specific sensor feature channels based on log content, functionally similar to an attention mechanism. For example, a log entry of "device enters standby mode" can generate a parameter that brings the γ value of energy-related feature channels close to zero, effectively "turning off" that feature. The β parameter, on the other hand, can perform translation, changing the activation baseline of the feature. This mechanism gives the model the ability to "disambiguate" sensor signals based on context; for example, it can distinguish between sharp fluctuations caused by "device testing" and genuine fault precursors, thus greatly improving early warning accuracy.

[0106] The core transformation in step F5 strictly follows the mathematical definition of FiLM: In the formula, This indicates element-wise or channel-wise multiplication. Refers to the modulated feature set output after modulation. The term refers to the sensor's intermediate layer feature map set modulated as input, where γ and β represent the scaling parameter tensor and offset parameter tensor obtained from the feature-level linear modulation parameter set (γ, β), respectively. This formula is used to perform the core feature-level affine transformation, that is, to conditionally and linearly adjust the high-level feature representation of the sensor data using parameters generated from log semantics. This operation is efficiently implemented through a broadcast mechanism, where each element of the γ and β vectors acts on one channel of the feature map. This method has proven effective in several visual and language tasks requiring conditional processing, and this scheme represents its innovative application in the field of multimodal temporal early warning. Finally, the modulated temporal features are concatenated with static knowledge graph features, a standard multimodal feature fusion technique aimed at integrating dynamic behavioral features with static attribute information.

[0107] The affine transformation performed in step F5 is central to the FiLM mechanism. The scaling parameter tensor γ acts as a dynamic, learnable "gating" or feature-level attention mechanism. When the log context indicates that a sensor feature is irrelevant or expected noise in the current context, the model can learn to generate a γ value close to zero to effectively "suppress" or "shut down" that feature channel. Conversely, if the context indicates that a feature is crucial, a larger γ value can be generated to "amplify" its influence. Simultaneously, the offset parameter β allows the model to dynamically shift the activation baseline of the feature. This combined mechanism gives the model a powerful, fine-grained ability to "recalibrate" and "reinterpret" physical sensor signals in real time based on observations from human experts, thus directly and mechanistically solving the problem of inaccurate warnings caused by signal ambiguity.

[0108] The implementation method of step F5 includes: Step F5F1, unpacking the feature-level linear modulation parameter set (γ, β) to obtain the scaling parameter tensor γ and the offset parameter tensor β. Step F5F2, applying a feature-level affine transformation to the corresponding elements of the scaling parameter tensor γ and the offset parameter tensor β for each feature map in the sensor intermediate layer feature map set to obtain the modulated feature map set. Step F5F3, applying a global average pooling operation in the time dimension to each feature map in the modulated feature map set to compress each feature map from a two-dimensional tensor into a one-dimensional vector, obtaining the modulated temporal feature vector set. Step F5F4, concatenating the modulated temporal feature vector set with the associated knowledge graph feature set one by one in the feature dimension to obtain the final fused multimodal feature vector set.

[0109] The fused multimodal feature vector set generated in step F5 is a shape of A two-dimensional floating-point tensor. In the logical chain, the core role of the fused multimodal feature vector set is to serve as the final, highly condensed, holistic representation of each operational event. Unprecedentedly, it integrates three heterogeneous information types within a unified vector space: dynamic temporal behavioral features actively adjusted by textual semantics, deep contextual semantics from logs, and static background attributes from knowledge graphs. The fused multimodal feature vector set will serve as the sole basis for subsequent classifier decisions.

[0110] The implementation method of step F5F2 includes: Step F5F2F1, adjusting the shapes of the scaling parameter tensor γ and the offset parameter tensor β, for example, through broadcasting, so that they can be batched and performed on a channel-by-channel element-wise basis with the shape of the sensor intermediate layer feature map set. Step F5F2F2, performing element-wise multiplication of the sensor intermediate layer feature map set with the adjusted scaling parameter tensor to obtain a product tensor. Step F5F2F3, performing element-wise addition of the product tensor with the adjusted offset parameter tensor to obtain the final modulated feature map set.

[0111] Step F6 involves inputting the fused multimodal feature vector set into the classifier defined by the classification head architecture parameters to obtain the final warning classification result set.

[0112] Step F6 is the key step in the entire process, responsible for mapping the carefully constructed, highly condensed feature vectors from the previous steps to specific warning categories. The classification head adopts a standard MLP structure, the complexity of which is determined by the classification head architecture parameters, sufficient to learn the non-linear mapping relationship between features and labels.

[0113] In step F6, the classifier's output layer employs the Normalized Exponential Activation Function (NEA), chosen as the standard for multi-class classification tasks. The NEA is the Softmax activation function, well-known to those skilled in the art, used to transform the model's original output, i.e., the logistic regression value, into a probability distribution where the sum of all element values ​​is 1.0. The final warning classification result set produced by step F6 is in list form, where each element is a dictionary representing the prediction result for that analysis window. This dictionary maps predefined category labels to corresponding prediction probabilities between 0.0 and 1.0. Predefined category labels include, for example, "Normal," "Level 1 Warning," and "Level 2 Alarm." This probabilistic output provides flexible and rich input information for subsequent decision-making steps.

[0114] The classifier architecture parameters are a dictionary of hyperparameters that define the final classifier network structure. Its internal configuration, such as the number of fully connected layers and the number of neurons per layer, is determined by performing a systematic hyperparameter optimization search on the validation set, such as a grid search, with the optimization objective of finding a network structure that most accurately maps the fused multimodal feature vector set to the true warning level labels.

[0115] The alert level sequence list is an ordered list of strings. Its content and order—the names and severity levels—are not derived from algorithmic learning or data inference, but rather predefined by business experts and risk managers with deep domain knowledge, based on operational procedures and a security risk matrix. The order of this list is crucial, directly encoding the alert escalation logic at the business level, and will be strictly followed by the decision rules in step F7.

[0116] When evaluating model performance, given that faulty samples are typically far fewer than normal samples in predictive maintenance scenarios, simple accuracy should be avoided. Metrics such as F1 score, area under the precision-recall curve, and balanced accuracy more accurately reflect the model's performance on imbalanced data and are more robust evaluation choices.

[0117] The implementation method of step F6 includes: Step F6F1, constructing a classifier network consisting of multiple fully connected layers and a normalized exponential activation function output layer based on the classification head architecture parameters. Step F6F2, inputting the fused multimodal feature vector set into the classifier network, performing batch forward propagation, and obtaining a warning classification result set representing the probability distribution of each warning category.

[0118] The warning classification result set generated in step F6 is a list containing multiple dictionaries, where each dictionary maps the level name in the warning level sequence table to a floating-point number between 0.0 and 1.0. In the logical chain, the core role of the warning classification result set is to serve as a quantified confidence assessment of the category to which each event belongs for the model. It is not the final decision, but rather a probabilistic intermediate output containing information about uncertainty. The warning classification result set will then serve as input to the final decision step F7, allowing it to apply deterministic business rules to select a unique final warning level.

[0119] Step F7: Apply the "maximum value" decision rule and determine and output the final warning level from the warning classification result set according to the warning level sequence list.

[0120] The implementation method of step F7 includes: Step F7F1, creating an initially empty list to store the highest probability prediction for all windows in this batch, named the "Prediction Level List for This Batch". Step F7F2, for each prediction result dictionary in the warning classification result set, find the key with the largest probability value, i.e., the level name, and add this key to the "Prediction Level List for This Batch". Step F7F3, temporarily storing the last level in the warning level sequence list, i.e., the least severe level, as the current highest level. Step F7F4, traversing each candidate level in the warning level sequence list, which is sorted in descending order of severity; if a candidate level exists in the "Prediction Level List for This Batch", setting the candidate level as the final warning level and immediately terminating the loop. Step F7F5, if the final warning level is still not set after traversing all candidate levels in the warning level sequence list, assigning the current highest level to the final warning level.

[0121] This embodiment details the data processing flow, precisely outlining a complete data evolution path from raw, heterogeneous data to final decision-making. This path begins with three independent data sources: raw sensor time-series data, raw operation and maintenance logs, and a knowledge graph of the utility tunnel equipment. Through time alignment anchored to the logs, these are integrated into synchronized data samples, producing aligned sensor sequence sets, aligned log text sets, and associated knowledge graph feature sets, respectively. Subsequently, in the parallel feature extraction stage, the aligned sensor sequence sets are encoded into a sensor intermediate layer feature map set by a 1D-CNN network, while the aligned log text sets are encoded into a log semantic embedding vector set by an SBERT model. The core turning point in the process is that the log semantic embedding vector set is used to generate a feature-level linear modulation parameter set (γ, β), which then performs conditional modulation on the sensor intermediate layer feature map set, producing a modulated feature map set. After pooling and concatenation with the associated knowledge graph feature set, a highly condensed, fused multimodal feature vector set is finally formed. This vector is fed into a classifier to generate a probabilistic set of warning classification results, and finally outputs a unique final warning level through deterministic decision rules.

[0122] The technical value of this process lies in its systematic solution to the long-standing problem of context-deficient predictive maintenance. By designing an innovative mechanism that proactively adjusts temporal feature processing based on textual semantics, this solution achieves a deep integration of human expert experience and machine signal analysis capabilities at the mechanistic level. It no longer merely identifies signal anomalies but attempts to "understand" the context in which the anomalies occur. This capability enables the system to produce more accurate, robust, and interpretable early warning judgments, thereby fundamentally enhancing the practical value and reliability of automated early warning systems in complex industrial scenarios.

[0123] Example 2

[0124] See Figure 2 As shown, this embodiment provides a progressive knowledge-injected early warning system for utility tunnels. The system includes:

[0125] The alignment module, based on the timestamps of the original operation and maintenance logs and according to the time window configuration, aligns, windowes, and extracts features from the original operation and maintenance logs, original sensor time-series data, and knowledge graph of the pipe gallery equipment, respectively, to obtain the aligned log text set, the aligned sensor sequence set, and the associated knowledge graph feature set;

[0126] The log semantic module selects the corresponding sentence vector representation model based on the specified sentence vector representation model identifier, performs batch encoding on the aligned log text set, and obtains the log semantic embedding vector set.

[0127] The sensing feature module uses a one-dimensional convolutional neural network defined by the architecture parameters of a one-dimensional convolutional neural network to perform batch feature extraction on the aligned sensor sequence set to obtain the sensor intermediate layer feature map set.

[0128] The parameter module takes the log semantic embedding vector set as input to the neural network defined by the feature-level linear modulation generator architecture parameters, and generates a scaling parameter tensor γ and an offset parameter tensor β for each feature map in the sensor intermediate layer feature map set, which together obtain the feature-level linear modulation parameter set (γ, β);

[0129] The feature stitching module performs a feature-level affine transformation on each feature map in the sensor intermediate layer feature map set using the corresponding parameters in the feature-level linear modulation parameter set (γ, β), and stitches the transformed result with the corresponding features in the associated knowledge graph feature set to obtain a fused multimodal feature vector set.

[0130] The classification module inputs the fused multimodal feature vector set into the classifier defined by the classification head architecture parameters to obtain the final warning classification result set;

[0131] The early warning module applies the maximum value decision rule and determines and outputs the final early warning level from the early warning classification result set according to the early warning level sequence list.

[0132] For any parts not mentioned in this application, existing technologies may be used or referenced.

[0133] The various embodiments in this specification are described in a progressive manner. The same or similar parts between the various embodiments can be referred to each other. Each embodiment focuses on describing the differences from other embodiments.

[0134] The above are merely embodiments of this application and are not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.

Claims

1. A method for constructing a utility tunnel early warning model with progressive knowledge injection, characterized in that, include: Step F1: Based on the timestamp of the original operation and maintenance log and according to the time window configuration, the original operation and maintenance log is aligned, windowed and feature extracted with the original sensor time series data and the knowledge graph of the pipe gallery equipment, respectively, to obtain the aligned log text set, the aligned sensor sequence set and the associated knowledge graph feature set; Step F2: Based on the specified sentence vector representation model identifier, select the corresponding sentence vector representation model and perform batch encoding on the aligned log text set to obtain the log semantic embedding vector set; Step F3: Using a one-dimensional convolutional neural network defined by the parameters of the one-dimensional convolutional neural network architecture, batch feature extraction is performed on the aligned sensor sequence set to obtain the sensor intermediate layer feature map set. Step F4: Input the log semantic embedding vector set into the neural network defined by the feature-level linear modulation generator architecture parameters to generate a scaling parameter tensor γ and an offset parameter tensor β for each feature map in the sensor intermediate layer feature map set, and obtain the feature-level linear modulation parameter set (γ, β); Step F5: For each feature map in the sensor intermediate layer feature map set, apply the corresponding parameters in the feature-level linear modulation parameter set (γ, β) to perform a feature-level affine transformation, and then concatenate the transformed result with the corresponding features in the associated knowledge graph feature set to obtain the fused multimodal feature vector set. Step F6: Input the fused multimodal feature vector set into the classifier defined by the classification head architecture parameters to obtain the final warning classification result set; Step F7: Apply the maximum value decision rule and determine and output the final warning level from the warning classification result set according to the warning level sequence list.

2. The method for constructing a pipe gallery early warning model with progressive knowledge injection according to claim 1, characterized in that, The implementation methods for step F4 include: Step F4F1 sets the batch size to the number of vectors contained in the log semantic embedding vector set; Step F4F2: Obtain the number of channels in a single sensor intermediate layer feature map in the sensor intermediate layer feature map set, denoted as C; Step F4F3: Based on the feature-level linear modulation generator architecture parameters, construct a multilayer perceptron model with the dimension of a single log semantic embedding vector as the input dimension and the output dimension as 2×C, to obtain the feature-level linear modulation generator network. Step F4F4: Input the log semantic embedding vector set into the feature-level linear modulation generator network, perform batch forward propagation, and obtain a two-dimensional feature-level linear modulation raw output tensor, wherein the size of the first dimension of the tensor is the batch size, and the size of the second dimension is 2×C. Steps F4 and F5 involve splitting the original output tensor of the feature-level linear modulation in the last dimension to obtain the scaling parameter tensor γ and the offset parameter tensor β. The scaling parameter tensor and the offset parameter tensor are two-dimensional tensors with the size of the batch size in the first dimension and the size of C in the second dimension. In steps F4 and F6, the scaling parameter tensor γ and the offset parameter tensor β are encapsulated into a single logical unit to obtain the feature-level linear modulation parameter set (γ, β).

3. The method for constructing a pipe gallery early warning model with progressive knowledge injection according to claim 2, characterized in that, The implementation methods for steps F4 and F3 include: Step F4F3F1: Read the architecture configuration parameters for defining the multilayer perceptron structure from the feature-level linear modulation generator architecture parameter dictionary. The architecture configuration parameters include at least a list of the number of hidden layer neurons and activation functions. Steps F4F3F2 involve constructing the feature-level linear modulation generator network, which is a multilayer perceptron consisting of an input layer, one or more hidden layers, and an output layer connected in sequence. Specifically: the number of neurons in the input layer is equal to the dimension of a single log semantic embedding vector; the number of layers and the number of neurons in each of the one or more hidden layers are determined by a list of the number of neurons in the hidden layers, and the hidden layers use the activation function; the number of neurons in the output layer is equal to twice the number of channels.

4. The method for constructing a pipe gallery early warning model with progressive knowledge injection according to claim 1, characterized in that, The implementation methods for step F5 include: Step F5F1: Unpack the feature-level linear modulation parameter set (γ, β) to obtain the scaling parameter tensor γ and the offset parameter tensor β; Step F5F2: For each feature map in the sensor intermediate layer feature map set, apply the corresponding elements in the scaling parameter tensor γ and the offset parameter tensor β to perform a feature-level affine transformation to obtain the modulated feature map set. Step F5F3: Apply global average pooling operation in the time dimension to each feature map in the modulated feature map set to compress each feature map from a two-dimensional tensor into a one-dimensional vector, and obtain the modulated temporal feature vector set. Step F5F4 involves concatenating the modulated temporal feature vector set with the associated knowledge graph feature set one by one along the feature dimension to obtain the final fused multimodal feature vector set.

5. The method for constructing a pipe gallery early warning model with progressive knowledge injection according to claim 4, characterized in that, The implementation methods for steps F5 and F2 include: Step F5F2F1: Adjust the shape of the scaling parameter tensor and the offset parameter tensor, and expand the two two-dimensional tensors into three-dimensional tensors respectively. The newly added dimension is used to align with the time dimension of the sensor intermediate layer feature map during computation. Step F5F2F2 involves performing element-wise multiplication of the sensor intermediate layer feature map set with the adjusted scaling parameter tensor to obtain the product tensor. Steps F5F2F3 involve performing element-wise addition operations on the product tensor and the adjusted offset parameter tensor to obtain the final modulated feature map set.

6. The method for constructing a pipe gallery early warning model with progressive knowledge injection according to claim 1, characterized in that, The implementation methods for step F6 include: Step F6F1: Based on the classification head architecture parameters, construct a classifier network consisting of multiple fully connected layers and a normalized exponential activation function output layer; Step F6F2 involves inputting the fused multimodal feature vector set into the classifier network and performing batch forward propagation to obtain a set of early warning classification results representing the probability distribution of each early warning category.

7. The method for constructing a pipe gallery early warning model with progressive knowledge injection according to claim 1, characterized in that, The implementation methods for step F7 include: Step F7F1: Create an initially empty list to store the highest probability prediction for all windows in this batch, and name it the "Prediction Level List for This Batch". Step F7F2: For each prediction result dictionary in the early warning classification result set, find the early warning level with the highest probability value and add the found early warning level to the prediction level list for this batch. Step F7F3: Temporarily save the last level in the warning level sequence list as the current highest level; Step F7F4: Iterate through each candidate level in the warning level sequence list. If a candidate level exists in the prediction level list for this batch, set the candidate level as the final warning level and terminate the loop immediately. In step F7F5, if the final warning level is still not set after traversing all candidate levels in the warning level sequence table, then the current highest level is assigned to the final warning level.

8. A progressive knowledge-injected early warning system for utility tunnels, characterized in that, The system is used to implement the method for constructing a pipeline corridor early warning model with progressive knowledge injection as described in any one of claims 1-7, and includes: The alignment module, based on the timestamps of the original operation and maintenance logs and according to the time window configuration, aligns, windowes, and extracts features from the original operation and maintenance logs, original sensor time-series data, and knowledge graph of the pipe gallery equipment, respectively, to obtain the aligned log text set, the aligned sensor sequence set, and the associated knowledge graph feature set; The log semantic module selects the corresponding sentence vector representation model based on the specified sentence vector representation model identifier, performs batch encoding on the aligned log text set, and obtains the log semantic embedding vector set. The sensing feature module uses a one-dimensional convolutional neural network defined by the architecture parameters of a one-dimensional convolutional neural network to perform batch feature extraction on the aligned sensor sequence set to obtain the sensor intermediate layer feature map set. The parameter module takes the log semantic embedding vector set as input to the neural network defined by the feature-level linear modulation generator architecture parameters, and generates a scaling parameter tensor γ and an offset parameter tensor β for each feature map in the sensor intermediate layer feature map set, which together obtain the feature-level linear modulation parameter set (γ, β); The feature stitching module performs a feature-level affine transformation on each feature map in the sensor intermediate layer feature map set using the corresponding parameters in the feature-level linear modulation parameter set (γ, β), and stitches the transformed result with the corresponding features in the associated knowledge graph feature set to obtain a fused multimodal feature vector set. The classification module inputs the fused multimodal feature vector set into the classifier defined by the classification head architecture parameters to obtain the final warning classification result set; The early warning module applies the maximum value decision rule and determines and outputs the final early warning level from the early warning classification result set according to the early warning level sequence list.

Images