Pipe network leakage time period positioning method based on continuous time chart

Abstract

The invention discloses a pipe network leakage time period positioning method based on a continuous time chart, and the method specifically comprises the following steps: 1, collecting the data of a water pipe network, including pressure data Ps and a leakage time period label Ls, and dividing Ps and Ls into a training set and a test set; step 2, establishing a continuous time dynamic graph G for the acquired water pipe network data, and performing meta-path generation and node embedding representation learning on G to obtain a node embedding representation E of G; step 3, designing a water pipe network leakage prediction network LeakP, wherein the leakage prediction network LeakP comprises a Shenchang differential equation sub-network Node, a feature prediction sub-network LstmP and a classification sub-network Cla; 4, training parameters are set, the graph G and the node embedding representation E of the graph G are sent into a network LeakP for training, and a network model ModelP is obtained; and step 5, sending the graph G and the node embedding representation E into a network LeakP, testing by using a model ModelP to obtain a prediction category score and a data label, and evaluating the leakage positioning performance according to a test index to realize accurate leakage time period positioning.

Description

Technical Field

[0001] The invention belongs to the technical field of water pipe network leakage period positioning method, and specifically relates to a pipe network leakage period positioning method based on a continuous time graph. Background Art

[0002] Pipeline leakage period positioning is an important part of pipeline maintenance. Due to the complexity of the pipeline structure, the randomness of leakage, and the dynamic changes of leakage, it is difficult to accurately locate the leakage period. Therefore, accurately locating the leakage period is still a major challenge in the current management and maintenance of water pipe networks. The occurrence of leakage events is often accompanied by complex dynamic system responses. Therefore, static distribution cannot be extracted from historical data when conducting pipeline leakage detection. At the same time, the lack of leakage data will also aggravate the limitations of historical data. The traditional leakage period positioning method based on hydraulic models is complex in model construction and calibration, depends on data quality, and the algorithm has uncertainty. Therefore, in order to achieve accurate leakage positioning on dynamic data, it is necessary to propose a continuous-time dynamic graph water pipe network leakage period positioning method. Summary of the invention

[0003] The purpose of the present invention is to provide a method for locating the leakage period of a pipeline network based on a continuous time graph, use the continuous time graph to establish a dynamic heterogeneous relationship between the nodes and the state of the pipeline network, and use the embedded representation method of the node to extract the dynamic distribution of historical data, and finally use the leakage prediction network to predict the node state, so as to improve the accuracy of the leakage period locating method.

[0004] The technical solution adopted by the present invention is a method for locating the leakage period of a pipe network based on a continuous time graph, which specifically includes the following steps:

[0005] Step 1: Collect water pipe network data, including pressure data Ps and leakage period label Ls, and divide Ps and Ls into training sets {Ps train ,Ls train} and the test set {Ps test ,Ls test};

[0006] Step 2: Establish a continuous-time dynamic graph G for the acquired water pipe network data, perform meta-path generation and node embedding representation learning on G, and obtain the node embedding representation E of G, G = G1||G2, E = E1||E2, G1 and G2 are {Ps train ,Ls train} and {Ps test ,Ls test} Corresponding dynamic graph, E1 and E2 are the node embedding representations of G1 and G2 respectively;

[0007] Step 3, design a water pipe network leakage prediction network LeakP, which includes a neural ordinary differential equation subnetwork NOde, a feature prediction subnetwork LstmP and a classification subnetwork Cla; define a loss function LossP;

[0008] Step 4, set the training parameters, send the graph G1 and the node embedding representation E1 of the graph G1 into the network LeakP for training, and obtain the network model ModelP;

[0009] Step 5: Send graph G2 and the node embedding representation E2 of graph G2 into the network LeakP, use model ModelP to test, get the predicted category score score and data label label, and evaluate the leakage location performance according to the test indicators.

[0010] The present invention is also characterized in that:

[0011] The specific process of step 1 is as follows:

[0012] Step 1.1, obtain the water pipe network pressure data set Ps and leakage period label set Ls from the water pipe network database, in, and They represent the pressure value and leakage truth label of the nth measuring point at the tth moment, N is the total number of measuring points in the water pipe network, T all The total length of pressure data collected for a single measurement point;

[0013] Step 1.2, according to the time length ratio T train :T test =7:3, the water pipe network pressure data set Ps and the leakage period label set Ls are divided into the training set {Ps train ,Ls train} and the test set {Ps test ,Ls test}, where, for the training set: Ps train For training water collection network pressure data, Ls train is the true value label of the leakage period of the training set, T train is the time length of the pressure data of the training set; for the test set: Ps test To test the water collection network pressure data, Ls test is the true value label of the test set leakage period, T test is the time length of the test set pressure data.

[0014] The specific process of step 2 is:

[0015] Step 2.1, define the continuous time dynamic graph G, in, is the node set of the continuous-time dynamic graph, vs and ss are the water pipe network measurement point set and measurement point status set respectively. is the nth measurement point at time t, The measurement point numbers and corresponding pressure data at time t are n and Right now is the nth measurement point v n The leakage state at time t is n∈[1,N],t∈[1,T all ], E is the edge set of the continuous-time dynamic graph, E t is the relationship set between all measurement points and their corresponding states at time t; is the time set of G;

[0016] Step 2.2, send G1 and G2 to the meta-path generation module respectively, and output the meta-path sets MS1 and MS2;

[0017] In step 2.3, (G1, MS1) and (G2, MS2) are respectively sent to the meta-path node embedding representation learning module to generate the embedding representation matrices E1 and E2 of V1 and V2.

[0018] The specific process of step 2.2 is:

[0019] Step 2.2.1, input the constructed continuous-time dynamic graph G into the random walk meta-path extraction module, where G is equal to G1 or G2; define the meta-path set Ms = {outline[1],…,outline[n],…,outline[N]}, where outline[n] is the nth node v in G n The corresponding meta-path set, N is the total number of nodes, outline[n] = {outline[n][1],…,outline[n][j],…,outline[n][num]}, outline[n][j] is v n The j-th meta-path of is initialized to an empty set, that is, outline[n][j] = Null, Ms = Null, 1≤j≤num, num is the total number of meta-paths of each node, and outline[n][j][i] is defined as the i-th element of outline[n][j], 1≤i≤len, len is the total number of elements in each meta-path outline[n][j], n and j are initialized to 1;

[0020] Step 2.2.2, randomly select the nth node at time t from the node set V of the continuous-time dynamic graph G, that is Among them, Random.choice() is a random selection function. Assign the value to the initial node variable node_0, that is

[0021] Step 2.2.3, i is initialized to 1, outline[n][j][i] = node_0, that is, outline[n][j] = {node_0}, define the current node variable Current_node, and define the initial time variable Current_time of Current_node;

[0022] Step 2.2.4, assign values ​​to Current_node and Current_time, Current_node = node_0,

[0023] Step 2.2.5, define the state set variable States, initialize it to empty, define the intermediate state variable State, and the intermediate node set variable nodes;

[0024] (1) exist Extract nodes from the edge set E The corresponding state at all times t Assign to States;

[0025] (2) Call the python library function Radom.choice(States) to randomly select a state in States and assign it to State, State = Radom.choice(States);

[0026] (3) If i<len, i=i+1, outline[n][j][i]=State, otherwise go to step 2.2.7;

[0027] (4) Extract the state in edge set E Corresponding to all nodes under t Assign values ​​to nodes, that is 1≤ln≤LN, LN is the total number of nodes in nodes;

[0028] (5) Call the math library function exp() in Python to calculate the weight Weight[ln] between Current_node and all nodes in nodes, that is, Weight[ln] = math.exp(-|tt ln |), sum all Weight[ln] and assign it to the variable totalweight, Calculate the probability of all nodes in nodes being selected to join the meta-path prolobalities[ln] = Weight[ln] / totalweight, call the random selection function next_node = Radom.choices(nodes,prolobalities), select the node with the largest probability value from nodes and assign it to the next node variable next_node of the current node in the meta-path;

[0029] (6) Assign a value to the time variable next_time corresponding to the next node, that is,

[0030] Step 2.2.6, if i<len, i=i+1, outline[n][j][i]=next_node, update Current_node and Current_time, that is, Current_node=next_node, Current_time=next_time, return to step 2.2.5, otherwise go to step 2.2.7;

[0031] Step 2.2.7, if j<num, j=j+1, go to step 2.2.3, otherwise go to step 2.2.8;

[0032] Step 2.2.8, if n<N, n=n+1, go to step 2.2.2, otherwise, output Ms, when G=G1, Ms1=Ms, when G=G2, Ms2=Ms.

[0033] The specific process of step 2.3 is:

[0034] Step 2.3.1, send (G, MS) to the meta-path node embedding representation learning module to generate the embedding representation matrix E of node V, (G, MS) is (G1, MS1) or (G2, MS2), define the meta-path set meta_path, meta_path = Reshape(MS, N×num), set the context window size w, set the node embedding dimension size ed and the node embedding size es, define the current node embedding matrix E of size es×ed, the context node embedding matrix E′ of the current node, and use the init.uniform() function in Pytorch to initialize E and E′; define the loss function variable L, and initialize L = 0; define the current node embedding variable current_node_emb, define the positive sample node embedding variable nodes_emb, define the negative sample node embedding variable neg_nodes_emb, set the number of nodes sampled by negative samples num_sample, define the meta-path count variable i, and initialize i = 1;

[0035] Step 2.3.2, define the meta-path node count variable c, initialize c = 1, define the current node number as current_node, the context node set of the current node as nodes, the context node number as nodes.num, the negative sample node set of the current node as neg_nodes, the negative sample node number as neg_nodes.num; define the positive sample loss score variable pos_score, define the negative sample loss score variable neg_score;

[0036] Step 2.3.3, assign values ​​to the current node, the context node of the current node, and the negative sample node, current_node = meta_path[i][c], meta_path[i][c] is the cth node of the ith meta-path in meta_path, assign the nodes contained in the context window w of current_node to nodes, that is, nodes = meta_path[i][cw / 2:c+w / 2], and use the random selection function random.sample() to select from Randomly select num_sample nodes as negative samples and assign them to neg_nodes, that is,

[0037] Step 2.3.4, assign a value to current_node_emb, current_node_emb = E[current_node]. Assign a value to nodes_emb, nodes_emb = E′[nodes.num], assign a value to neg_nodes_emb, neg_nodes_emb = E′[neg_nodes.num]; call the element-by-element multiplication function mul() in Pytorch to calculate the element-by-element multiplication result mul_out of current_node_emb and nodes_emb, mul_out = mul(current_node_emb, nodes_emb), use the activation function logsigmoid() to calculate the positive sample loss score and assign it to pos_score, the calculation formula is as follows:

[0038]

[0039] Use the batch matrix multiplication function bmm() in Pytorch to calculate bmm_out, bmm_out = bmm(current_node_emb, neg_nodes_emb), use the activation function logsigmoid() function to calculate the negative sample loss score, and assign it to neg_score. The calculation formula is as follows:

[0040]

[0041] Use the mean() function to average the sum of the positive sample loss score pos_score and the negative sample loss score neg_score, and assign it to L. The calculation formula is as follows:

[0042] L=mean(pos_score,neg_score)=(pos_score+neg_score) / 2

[0043] Step 2.3.5, if c<len, c=c+1, according to the value of L, call the L.backward() function in the open source Pytorch to adjust the values ​​of E and E′, and go to step 2.3.3;

[0044] Step 2.3.6, if i<N×num, i=i+1, initialize c=1, and go to step 2.3.3, otherwise output the current node embedding matrix E, if (G, Ms) is equal to (G1, Ms1), E1=E, if (G, Ms) is equal to (G2, Ms2), E2=E.

[0045] The specific process of step 3 is:

[0046] Step 3.1, send G and E as input to the Neural Ordinary Differential Equation subnetwork NOde to obtain the continuous dynamic representation z of the node, z = NOde (G, E);

[0047] Step 3.2, respectively set the input data feature dimension variable input_size, the hidden layer dimension variable hidden_size and the network layer number variable num_layers, and construct the feature prediction subnetwork structure LstmP according to the set variables, that is, LstmP = LSTM (input_size, hidden_size, num_layers), where LSTM () is an open source feature prediction network function in Pytorch, and the continuous dynamic representation z of the node is taken as input and sent to LstmP to obtain the predicted feature feature, that is, feature = LstmP (z);

[0048] Step 3.3, take the predicted feature feature as input and send it to the classification subnetwork Cla to obtain the predicted category score score, that is, score = Cla (feature);

[0049] Step 3.4, define the loss function LossP as LossP = BCELoss(score, label), where score and label are the predicted category score and the state of the measurement point obtained in step 3.3, respectively. BCELoss() is the open source binary cross entropy loss function in Pytorch. The calculation formula is as follows. SN is the number of data in score:

[0050]

[0051] The specific process of step 4 is:

[0052] Step 4.1, set the training parameters of the leakage prediction network LeakP, the training parameters include batch data size batch_size, maximum iteration number epoch_max, minimum change value of loss function ΔMinlossP, learning rate initlr, network optimizer as optimizer, define the network training iteration number variable epoch, initialize it to 1, and define the loss function change value variable ΔLossP;

[0053] Step 4.2: Send the graph G1 and the node embedding representation E1 of the graph G1 in step 3 to the network structure LeakP for training in batches according to the batch_size size, and obtain the predicted category score score1. The true value label label1 is the node state corresponding to G1. Calculate the loss value LossP epoch , LossP epoch=BCELoss(score1,label1), when epoch>1, calculate the loss function change value ΔLossP, ΔLossP=|LossP epoch -LossP epoch-1 |, where LossP epoch and LossP epoch-1 is the loss value of the epoch and epoch-1 generations;

[0054] Step 4.3, if epoch<epoch_max or ΔLossP>ΔMinlossP, then epoch=epoch+1, use optimizer to reversely correct the weight coefficients of each network layer in the water pipe network leakage prediction network structure LeakP, and return to step 4.2; otherwise, end the training and output the network model ModelP.

[0055] The specific process of step 5 is:

[0056] Step 5.1, send the graph G2 and its node embedding representation E2 into the network LeakP, and use the model ModelP to get the predicted category score score2=score;

[0057] Step 5.2, use the average precision function average_precision_score() in the Python open source library sklearn as the main evaluation indicator of network performance, and get the evaluation result ap. The calculation formula is:

[0058] ap=average_precision_score(score2,label2)

[0059] Among them, the true value label label2 is the node state corresponding to G2

[0060] The beneficial effects of the present invention are as follows: the present invention assumes the pipe network measurement point (or sensor) as one object, assumes the normal and leakage states of the pipeline as another object, defines a meta-path composed of different types of objects to capture the semantics and structure of a heterogeneous information network, adopts a meta-path-based random walk to construct a heterogeneous neighborhood of a node, uses a Skip-gram model to learn node embedding, uses a Neural Ordinary Differential Equation (ODE) to model the continuous time representation of the node, and finally uses LSTM and a classification subnetwork as a decoder to predict the probability of interaction between a given node and a leakage state, so as to achieve accurate leakage period positioning. BRIEF DESCRIPTION OF THE DRAWINGS

[0061] Figure 1 It is a flow chart of the method for locating the leakage period of a pipe network based on a continuous time graph of the present invention;

[0062] Figure 2 It is a network structure diagram of the method for locating the leakage period of a pipe network based on a continuous time graph of the present invention;

[0063] Figure 3 It is a dynamic heterogeneous graph based on leakage interaction events in the method for locating leakage periods of pipe networks based on continuous time graphs of the present invention;

[0064] Figure 4(a) is the topological structure of the Net1 pipe network system;

[0065] Figure 4(b) is the topological structure of the Hanoi pipe network system. DETAILED DESCRIPTION

[0066] The present invention is described in detail below with reference to the accompanying drawings and specific embodiments.

[0067] Example 1

[0068] The present invention is based on a method for locating leakage periods of pipeline networks based on a continuous time graph. The dynamic information of the pipeline network is used to accurately locate the leakage period. A connection is established between the pipeline network nodes and the pipeline network leakage status through a graph network and a meta-path. The Neural Ordinary Differential Equation (ODE) is used to solve the dynamic process of pipeline network leakage changing over time to obtain a continuous dynamic representation of the node. Finally, LSTM is used as a decoder to obtain the probability of node leakage period occurrence, thereby accurately locating the period when the leakage occurs.

[0069] Example 2

[0070] The present invention is based on a method for locating leakage periods in a pipe network using a continuous time graph, such as Figure 1 As shown, the specific steps include:

[0071] Step 1: Collect or obtain water pipe network data on the official website, namely, pressure data Ps and leakage period label Ls, and divide Ps and Ls into training sets {Ps train ,Ls train} and the test set {Ps test ,Ls test};

[0072] The specific process of step 1 is as follows:

[0073] Step 1.1, obtain the water pipe network pressure data set Ps and leakage period label set Ls from the water pipe network database, in, and They represent the pressure value and leakage truth label of the nth measuring point at the tth moment, N is the total number of measuring points in the water pipe network, T all Total length of pressure data collected for a single measurement point, N and T allThe values ​​are 200 and 17520 respectively;

[0074] Step 1.2, according to the time length ratio T train :T test =7:3, where T train =12264,T test =5256, the water pipe network pressure data set Ps and the leakage period label set Ls are divided into training sets {Ps train ,Ls train} and the test set {Ps test ,Ls test}, where, for the training set: Ps train For training water collection network pressure data, Ls train is the true value label of the leakage period of the training set, T train is the time length of the pressure data of the training set. For the test set: Ps test To test the water collection network pressure data, Ls test is the true value label of the test set leakage period, T test is the time length of the test set pressure data.

[0075] The network structure of the method for locating the leakage period of the pipeline network based on the continuous time graph of the present invention is as follows: Figure 2 As shown, it specifically includes steps 2 and 3:

[0076] Step 2: Node embedding representation part: establish a continuous time dynamic graph G for the acquired water pipe network data. Based on the Metapath2vec model, we learn the node embedding representation of G and get the node embedding representation E of G, where G = G1||G2, E = E1||E2, G1 and G2 are {Ps train ,Ls train} and {Ps test ,Ls test} corresponding to the dynamic graph, E1 and E2 are the node embedding representations of G1 and G2 respectively. This part consists of the input module, the continuous time dynamic graph construction module, the meta-path generation module and the meta-path node embedding representation learning module. The specific process is as follows:

[0077] Step 2.1, input module, use the training set {Ps train ,Ls train} as input, Use the test set {Ps test ,Ls test} as input,

[0078] Step 2.2, continuous time dynamic graph construction module, such as Figure 3 As shown, define the continuous time dynamic graph G, in, is the node set of the continuous-time dynamic graph, vs and ss are the water pipe network measurement point set and measurement point status set respectively. is the nth measurement point at time t, The measurement point numbers and corresponding pressure data at time t are n and Right now is the nth measurement point v n The leakage state at time t is n∈[1,N],t∈[1,T all ], E is the edge set of the continuous-time dynamic graph, E t is the relationship set between all measurement points and their corresponding states at time t; is the time set of G;

[0079] Use Ps during training train and Ls train Assign data to G to obtain the continuous time dynamic graph G1 of training data. Use Ps when testing test and Ls test Assign data to G to obtain the test data continuous time dynamic graph G2, When When G1=G, When G1=G;

[0080] Step 2.3, send G1 and G2 to the meta-path generation module respectively, and output the meta-path sets MS1 and MS2;

[0081] Step 2.3.1, random walk meta-path extraction module, input the constructed continuous-time dynamic graph G, where G is equal to G1 or G2. Define the meta-path set Ms = {outline[1],…,outline[n],…,outline[N]}, where outline[n] is the nth node v in G n The corresponding meta-path set, N is the total number of nodes, N = 200, outline[n] = {outline[n][1],…,outline[n][j],…,outline[n][num]}, outline[n][j] is v nThe j-th meta-path of is initialized to an empty set, that is, outline[n][j] = Null, Ms = Null, 1≤j≤num, num is the total number of meta-paths for each node, num = 1000, and outline[n][j][i] is defined as the i-th element of outline[n][j] (that is, the i-th point passed by the meta-path), 1≤i≤len, len is the total number of elements in each meta-path outline[n][j], len = 600, n and j are initialized to 1;

[0082] Step 2.3.2, from the node set of the continuous time dynamic graph G In the example, we randomly select the nth node at time t, that is, Among them, Random.choice() is a random selection function. Assign the value to the initial node variable node_0, that is

[0083] Step 2.3.3, i is initialized to 1, outline[n][j][i] = node_0, that is, outline[n][j] = {node_0}, define the current node variable Current_node, and define the initial time variable Current_time of Current_node;

[0084] Step 2.3.4, assign values ​​to Current_node and Current_time, Current_node = node_0,

[0085]

[0086] Step 2.3.5, define the state set variable States, initialize it to empty, define the intermediate state variable State, and the intermediate node set variable nodes;

[0087] (1) exist Extract nodes from the edge set E The corresponding state at all times t Assign to States;

[0088] (2) Call the python library function Radom.choice(States) to randomly select a state in States and assign it to State, State = Radom.choice(States);

[0089] (3) If i<len, i=i+1, outline[n][j][i]=State, otherwise go to step 2.3.7;

[0090] (4) Extract the state in edge set E Corresponding to all nodes at time t Assign values ​​to nodes, that is 1≤ln≤N;

[0091] (5) Call the math library function exp() in Python to calculate the weight Weight[ln] between Current_node and all nodes in nodes, that is, Weight[ln] = math.exp(-|tt ln |), sum all Weight[ln] and assign it to the variable totalweight, Calculate the probability of all nodes in nodes being selected to join the meta-path prolobalities[ln] = Weight[ln] / totalweight, call the random selection function next_node = Radom.choices(nodes,prolobalities), select the node with the largest probability value from nodes and assign it to the next node variable next_node of the current node in the meta-path;

[0092] (6) Assign a value to the time variable next_time corresponding to the next node, that is,

[0093] Step 2.3.6, if i<len, i=i+1, outline[n][j][i]=next_node, update Current_node and Current_time, that is, Current_node=next_node, Current_time=next_time, go to step 2.3.5, otherwise go to step 2.3.7;

[0094] Step 2.3.7, if j<num, j=j+1, go to step 2.3.3, otherwise go to step 2.3.8;

[0095] Step 2.3.8, if n<N, n=n+1, go to step 2.3.2, otherwise, output Ms, when G=G1, Ms1=Ms, when G=G2, Ms2=Ms;

[0096] Step 2.4, send (G1, MS1) and (G2, MS2) to the meta-path node embedding representation learning module respectively to generate the embedding representation matrices E1 and E2 of V1 and V2;

[0097] Step 2.4.1, send (G, MS) to the meta-path random walk module to generate the embedding representation matrix E of node V, (G, MS) can be (G1, MS1) or (G2, MS2), define the meta-path set meta_path, meta_path = Reshape (MS, N×num), set the context window size w = 7, set the node embedding dimension size ed = 172 and the node embedding size es = 202, define the current node embedding matrix E of size es×ed, the context node embedding matrix E′ of the current node, and use the init.uniform() function in Pytorch to initialize E and E′. Define the loss function variable L, and initialize L = 0. Define the current node embedding variable current_node_emb, define the positive sample node embedding variable nodes_emb, define the negative sample node embedding variable neg_nodes_emb, set the number of nodes sampled by negative samples num_sample = 5, define the meta-path count variable i, and initialize i = 1.

[0098] Step 2.4.2, define the meta-path node count variable c, initialize c = 1, define the current node number as current_node, the context node set of the current node as nodes, the context node number as nodes.num, the negative sample node set of the current node as neg_nodes, the negative sample node number as neg_nodes.num; define the positive sample loss score variable pos_score, define the negative sample loss score variable neg_score;

[0099] Step 2.4.3, assign values ​​to the current node, the context node of the current node, and the negative sample node, current_node = meta_path[i][c], meta_path[i][c] is the cth node of the ith meta-path in meta_path, assign the nodes contained in the context window w of current_node to nodes, that is, nodes = meta_path[i][cw / 2:c+w / 2]; use the random selection function random.sample() to randomly select num_sample nodes from V as negative samples and assign them to neg_nodes, that is, neg_nodes = random.sample(V,num_sample);

[0100] Step 2.4.4, assign a value to current_node_emb, current_node_emb = E[current_node]. Assign a value to nodes_emb, nodes_emb = E′[nodes.num], assign a value to neg_nodes_emb, neg_nodes_emb = E′[neg_nodes.num]. Call the element-by-element multiplication function mul() in Pytorch to calculate the element-by-element multiplication result mul_out of current_node_emb and nodes_emb, mul_out = mul(current_node_emb, nodes_emb), use the activation function logsigmoid() to calculate the positive sample loss score and assign it to pos_score, the calculation formula is as follows:

[0101]

[0102] Use the batch matrix multiplication function bmm() in Pytorch to calculate bmm_out, bmm_out = bmm(current_node_emb, neg_nodes_emb), use the activation function logsigmoid() function to calculate the negative sample loss score, and assign it to neg_score. The calculation formula is as follows:

[0103]

[0104] Use the mean() function to average the sum of the positive sample loss score pos_score and the negative sample loss score neg_score, and assign it to L. The calculation formula is as follows:

[0105] L=mean(pos_score,neg_score)=(pos_score+neg_score) / 2

[0106] Step 2.4.5, if c<len, c=c+1, according to the value of L, call the L.backward() function in the open source Pytorch to adjust the values ​​of E and E′, and go to step 2.4.3;

[0107] Step 2.4.6, if i<N×num, i=i+1, initialize c=1, and go to step 2.4.3, otherwise output the current node embedding matrix E, if (G, Ms) is equal to (G1, Ms1), E1=E, if (G, Ms) is equal to (G2, Ms2), E2=E.

[0108] Step 3, design the water pipe network leakage prediction network structure LeakP, and define the loss function LossP; the leakage prediction network LeakP consists of the Neural Ordinary Differential Equation subnetwork NOde, the feature prediction subnetwork LstmP and the classification subnetwork Cla; the specific process of step 3 is:

[0109] Step 3.1, the neural ordinary differential equation subnetwork NOde consists of three fully connected layers and two activation layers. The specific connection order is: fully connected layer ode_fc1→activation layer ELU1→fully connected layer ode_fc2→activation layer ELU2→fully connected layer ode_fc3. The input and output dimensions are shown in Table 1. G and E are taken as input and sent to NOde to obtain the continuous dynamic representation of the node z, z = NOde (G, E);

[0110] Table 1

[0111] Network layer name Input Dimensions Output Dimensions <![CDATA[ode_fc1]]> 172 172 <![CDATA[ELU1]]> / / <![CDATA[ode_fc2]]> 172 172 <![CDATA[ELU2]]> / / <![CDATA[ode_fc3]]> 172 172

[0112] Step 3.2, respectively set the input data feature dimension variable input_size, the hidden layer dimension variable hidden_size and the network layer number variable num_layers, and construct the feature prediction subnetwork structure LstmP according to the set variables, that is, LstmP = LSTM (input_size, hidden_size, num_layers), where LSTM () is an open source feature prediction network function in Pytorch, input_size = 172*3, hidden_size = 172, num_layers = 2, and take the continuous dynamic representation z of the node as input and send it to LstmP to obtain the predicted feature feature, that is, feature = LstmP (z);

[0113] Step 3.3, the classification subnetwork Cla consists of two fully connected layers and one activation layer. The specific connection order is: fully connected layer s_fc1→activation layer RELU→fully connected layer s_fc2. The input and output dimensions are shown in Table 2. The predicted feature feature is used as input and sent to Cla to obtain the predicted category score score, that is, score = Cla (feature);

[0114] Table 2

[0115] Network layer name Input Dimensions Output Dimensions <![CDATA[s_fc1]]> 172 81 RELU / / <![CDATA[s_fc2]]> 81 1

[0116] Step 3.4, the loss function LossP is defined as LossP = BCELoss(score, label), where score and label are the predicted category score and the state of the measurement point obtained in step 3.3 (a value of 1 indicates leakage and a value of 0 indicates non-leakage), BCELoss() is an open source binary cross entropy loss function in Pytorch, and the calculation formula is as follows, SN is the number of data in score:

[0117]

[0118] Step 4, set the training parameters, send the graph G1 and its node embedding representation E1 into the network LeakP for training, and obtain the network model ModelP; the specific process of step 4 is:

[0119] Step 4.1, set the training parameters of the leakage prediction network LeakP, the training parameters include batch data size batch_size = 200, maximum iteration number epoch_max = 50, minimum change value of loss function ΔMinlossP = 0.01, learning rate initlr = 0.01, network optimizer is optimizer, define the network training iteration number variable epoch, initialize it to 1, and define the loss function change value variable ΔLossP;

[0120] Step 4.2: Send the graph G1 and its node embedding representation E1 in step 3 to the network structure LeakP for training in batches according to batch_size, and obtain the predicted category score score1. The true value label label1 is the node state corresponding to G1. Calculate the loss value LossP epoch , LossP epoch =BCELoss(score1,label1), when epoch>1, calculate the change value of loss function ΔLossP, ΔLossP=|LossP epoch -LossP epoch-1 |, where LossP epoch and LossP epoch-1 is the loss value of the epoch and epoch-1 generations;

[0121] Step 4.3, if epoch<epoch_max or ΔLossP>ΔMinlossP, then epoch=epoch+1, use optimizer to reversely correct the weight coefficients of each network layer in the water pipe network leakage prediction network structure LeakP, and return to step 4.2; otherwise, end the training and output the network model ModelP.

[0122] Step 5: Send the graph G2 and its node embedding representation E2 to the network LeakP and ModelP for testing, obtain the predicted category score and data label, and evaluate the leakage location performance according to the test indicators. The specific process of step 5 is:

[0123] Step 5.1, send the graph G2 and its node embedding representation E2 into the network LeakP, and use the model ModelP to get the predicted category score score2=score;

[0124] Step 5.2, use the average precision function average_precision_score() in the Python open source library sklearn as the main evaluation indicator of network performance, and get the evaluation result ap. The calculation formula is:

[0125] ap=average_precision_score(score2,label2)

[0126] Among them, the true value label label2 is the node state corresponding to G2

[0127] Example 3

[0128] The leakage diagnosis benchmark dataset LeakDB proposed by Vrachimis et al. in 2018 is used as the training and testing dataset. This dataset contains a large number of real pipe network leakage scenarios that occur randomly in pipe networks of different sizes and topologies. The data includes two pipe network systems, Net1 and Hanoi.

[0129] The pipe network system provided by a scenario includes water demand (Demands folder), sensor flow (Flows folder), pressure (Pressure folder), leakage node information (Leaks folder), leakage period truth label (Labels.csv file), pipe network physical topology (inp type file), scenario basic information (Scenario-xxx_info.csv file) and data acquisition timestamp. It contains the operation of the Net1 pipe network system for 8760 hours a year, the data sampling frequency is once every 30 minutes, and the sensor data time series length of each node in the scenario is 17520. Compared with other sensor data, pressure data can better establish a connection with leakage, so all algorithms used are trained with pressure data.

[0130] 1) Net1 pipe network system

[0131] As shown in Figure 4(a), it is the physical topology of the Net1 water distribution network, which includes 11 nodes, 13 pipes, a reservoir, a water tank and a water pump. The dataset provides data of the Net1 pipe network system in 1000 scenarios.

[0132] 2) Hanoi Pipeline System

[0133] As shown in Figure 4(b), the Hanoi pipe network system in LeakDB is built according to an actual urban water supply pipe network in Hanoi, Vietnam. It includes 32 nodes, 34 pipes, 1 reservoir, and 3 loops. It can be seen that compared with Net1, it has a more complex topology and more loops, which makes leak detection and positioning more difficult. Therefore, Hanoi is very challenging for leak detection and positioning algorithms.

[0134] Results evaluation:

[0135] The evaluation model GRLD used in the control experiment comes from the article Bjerke M. "Leak Detection in Water Distribution Networks using Gated Recurrent Neural Networks" [D]. NTNU, 2019. The gated recurrent unit GRU algorithm is used; the model MLTLD comes from the article Maryam Kammoun, Amina Kammoun, Mohamed Abid. "Experiments based comparative evaluations of machine learning techniques for leak detection in water distribution systems" [J]. Water Supply 1 January, 2022. The multi-layer perceptron algorithm is used; the model DALA comes from the article N, I. "Deep Autoencoder Based Leakage Detection in Water Distribution SCADA Systems" [M]. Industrial Innovation in Digital Age, 2020. Use the LSTM-based deep autoencoder neural network; the model WLDCA comes from the article Leonzio DU, Bestagini P, Marcon M, et al. "Waterleak detection and localization using convolutional autoencoders" [C]. IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), 2023. Use the convolution-based autoencoder algorithm; the model WLDL comes from the article Kammoun M, Kammoun A, Abid M. "LSTM-AE-WLDL: Unsupervised LSTM Auto-Encoders for Leak Detection and Location in Water Distribution Networks" [J]. Water Resources Management, 2023. Use the LSTM autoencoder algorithm.

[0136] 1) Table 3 shows the objective comparison results of the proposed method and other leakage period localization methods in recent years on the Net1 dataset. As can be seen from the table, in terms of precision P, DALD has the highest score of 0.9814, while CTGLM has a precision of 0.9539, which is 0.0275 lower than DALD. Compared with other methods, it is slightly lower than WLDL and DALD, but higher than GRLD and MLTLD. In terms of recall R, CTGLM's recall rate reaches 0.9689, the highest among all methods, 0.007 higher than the second place, which shows that CTGLM is in leakage period localization. In terms of F1 score, CTGLM's F1 score is 0.9613, the highest among all methods, 0.0117 higher than the second place WLDL, which shows that CTGLM has achieved a good balance between precision and recall. In terms of accuracy ACC, CTGLM's accuracy reached 0.983, the highest among all methods, 0.0076 higher than the second-place WLDCA, which shows that CTGLM's overall leakage localization performance is very good. In terms of intersection over union (IOU), CTGLM's IOU reached 0.9241, 0.0219 higher than the second-place WLDL, which shows that CTGLM has the highest overlap in positioning the leakage period and the highest coverage of the leakage part in the positioning of the leakage period. In terms of false alarm rate (FPR), CTGLM's false alarm rate was 0.0107, which is higher than DALD and WLDL, and 0.0056 higher than the best DALD. Although it did not achieve the best in reducing false alarms, it has the best overall performance among all methods.

[0137] Table 3

[0138]

[0139]

[0140] In summary, it can be seen that the CTGLM method has a good performance on the Net1 dataset and shows the best performance in multiple evaluation indicators, especially in the four indicators of recall rate R, F1 score, accuracy rate ACC and intersection over union (IOU). It can effectively locate the leakage period, thereby ensuring the effective use of water resources and the safe operation of the pipe network.

[0141] 2) Table 4 shows the objective results of all methods on the Hanoi dataset. Overall, on the Hanoi dataset, the indicators of each method are not as good as those on the Net1 dataset, which also shows the complexity of the leakage on the Hanoi dataset. From the perspective of various indicators, in terms of precision P, the precision of CTGLM reached 0.9273, which is the best among all methods and 0.0474 higher than the second-place WLDL, which shows that the model of the method of the present invention has the highest accuracy in locating the leakage period. In terms of recall rate R, the recall rate of CTGLM reached 0.9351, ranking fourth among all methods, 0.0645 lower than the best WLDCA, which is mainly because the model's improvement in precision sacrificed part of the recall rate. In terms of F1 score, CTGLM is the best, reaching 0.9312, 0.0244 higher than the second-place WLDL, which shows that the method of the present invention achieves the best comprehensive performance. In terms of accuracy ACC, the method of the present invention reached 0.9702, the highest among all models, 0.0134 higher than the second-place WLDL, which shows the overall prediction accuracy of the method of the present invention. In terms of intersection over union (IOU), CTGLM is also the best, reaching 0.8733, 0.0431 higher than the second-place WLDL. In terms of false alarm rate (FPR), CTGLM is also the best, reaching 0.0222, 0.0152 lower than the second-place WLDL, which shows that the method of the present invention has the least false alarms.

[0142] Table 4

[0143]

[0144] In summary, it can be seen that the CTGLM method has a higher advantage in objective indicators compared with other methods on the Hanoi dataset, which shows the effectiveness of this method in locating leakage periods, especially the performance advantage of accurately locating leakage periods in the context of complex pipe networks.

Claims

1. A method for locating leakage periods of a pipe network based on a continuous time graph, characterized in that: The specific steps include: Step 1: Collect water pipe network data, including pressure data Ps and leakage period label Ls, and divide Ps and Ls into training sets {Ps train ,Ls train } and the test set {Ps test ,Ls test }; Step 2: Establish a continuous-time dynamic graph G for the acquired water pipe network data, perform meta-path generation and node embedding representation learning on G, and obtain the node embedding representation E of G, G = G1||G2, E = E1||E2, G1 and G2 are {Ps train ,Ls train } and {Ps test ,Ls test } Corresponding dynamic graph, E1 and E2 are the node embedding representations of G1 and G2 respectively; Step 3, design a water pipe network leakage prediction network LeakP, which includes a neural ordinary differential equation subnetwork NOde, a feature prediction subnetwork LstmP and a classification subnetwork Cla; define a loss function LossP; Step 4, send the graph G1 and the node embedding representation E1 of the graph G1 into the network LeakP for training to obtain the network model ModelP; Step 5: Send E2 to the network LeakP and use the model ModelP for testing to obtain the predicted category score and data label label, and evaluate the leakage location performance according to the test indicators.

2. The method for locating leakage periods of a pipe network based on a continuous time graph according to claim 1 is characterized in that: The specific process of step 1 is as follows: Step 1.1, obtain the water pipe network pressure data set Ps and leakage period label set Ls from the water pipe network database, in, and They represent the pressure value and leakage truth label of the nth measuring point at the tth moment, N is the total number of measuring points in the water pipe network, T all The total length of pressure data collected for a single measurement point; Step 1.2, according to the time length ratio T train :T test =7:3, the water pipe network pressure data set Ps and the leakage period label set Ls are divided into the training set {Ps train ,Ls train } and the test set {Ps test ,Ls test }, where, for the training set: Ps train For training water collection network pressure data, Ls train is the true value label of the leakage period of the training set, T train is the time length of the pressure data of the training set; for the test set: Ps test To test the water collection network pressure data, Ls test is the true value label of the test set leakage period, T test is the time length of the test set pressure data.

3. The method for locating leakage periods of a pipe network based on a continuous time graph according to claim 2 is characterized in that: The specific process of step 2 is: Step 2.1, define the continuous time dynamic graph G, in, is the node set of the continuous-time dynamic graph, vs and ss are the water pipe network measurement point set and measurement point status set respectively. is the nth measurement point at time t, The measurement point numbers and corresponding pressure data at time t are n and Right now is the nth measurement point v n The leakage state at time t is n∈[1,N],t∈[1,T all ], E is the edge set of the continuous-time dynamic graph, E t is the relationship set between all measurement points and their corresponding states at time t; is the time set of G; Step 2.2, send G1 and G2 to the meta-path generation module respectively, and output the meta-path sets MS1 and MS2; Step 2.3: Send (G1, MS1) and (G2, MS2) to the meta-path node embedding representation learning module to generate and The embedding representation matrices E1 and E2.

4. The method for locating leakage periods of a pipe network based on a continuous time graph according to claim 3 is characterized in that: The specific process of step 2.2 is as follows: Step 2.2.1, input the constructed continuous-time dynamic graph G into the random walk meta-path extraction module, where G is equal to G1 or G2; define the meta-path set Ms = {outline[1],…,outline[n],…,outline[N]}, where outline[n] is the nth node v in G n The corresponding meta-path set, N is the total number of nodes, outline[n] = {outline[n][1],…,outline[n][j],…,outline[n][num]}, outline[n][j] is v n The j-th meta-path of is initialized to an empty set, that is, outline[n][j] = Null, Ms = Null, 1≤j≤num, num is the total number of meta-paths of each node, and outline[n][j][i] is defined as the i-th element of outline[n][j], 1≤i≤len, len is the total number of elements in each meta-path outline[n][j], n and j are initialized to 1; Step 2.2.2, from the node set of the continuous time dynamic graph G In the example, we randomly select the nth node at time t, that is, Among them, Random.choice() is a random selection function, which takes vt n Assign the value to the initial node variable node_0, that is Step 2.2.3, i is initialized to 1, outline[n][j][i] = node_0, that is, outline[n][j] = {node_0}, define the current node variable Current_node, and define the initial time variable Current_time of Current_node; Step 2.2.4, assign values ​​to Current_node and Current_time, Current_node = node_0, Step 2.2.5, define the state collection variable States, initialize it to empty, define the intermediate state variable State, and the intermediate node collection variable nodes; (1) exist Extract nodes from the edge set E The corresponding state at all times t Assign to States; (2) Call the python library function Radom.choice(States) to randomly select a state in States and assign it to State, State = Radom.choice(States); (3) If i<len, i=i+1, outline[n][j][i]=State, otherwise go to step 2.2.7; (4) Extract the state in edge set E Corresponding to all nodes under t Assign values ​​to nodes, that is 1≤ln≤LN, LN is the total number of nodes in nodes; (5) Call the math library function exp() in Python to calculate the weight Weight[ln] between Current_node and all nodes in nodes, that is, Weight[ln] = math.exp(-|tt ln |), sum all Weight[ln] and assign it to the variable totalweight, Calculate the probability of all nodes in nodes being selected to join the meta-path prolobalities[ln] = Weight[ln] / totalweight, call the random selection function next_node = Radom.choices(nodes,prolobalities), select the node with the largest probability value from nodes and assign it to the next node variable next_node of the current node in the meta-path; (6) Assign a value to the time variable next_time corresponding to the next node, that is, Step 2.2.6, if i<len, i=i+1, outline[n][j][i]=next_node, update Current_node and Current_time, that is, Current_node=next_node, Current_time=next_time, return to step 2.2.5, otherwise go to step 2.2.7; Step 2.2.7, if j<num, j=j+1, go to step 2.2.3, otherwise go to step 2.2.8; Step 2.2.8, if n<N, n=n+1, go to step 2.2.2, otherwise, output Ms, when G=G1, Ms1=Ms, when G=G2, Ms2=Ms.

5. The method for locating leakage periods of a pipe network based on a continuous time graph according to claim 4 is characterized in that: The specific process of step 2.3 is as follows: Step 2.3.1, send (G, MS) to the meta-path node embedding representation learning module to generate node The embedding representation matrix E of (G, MS) is (G1, MS1) or (G2, MS2), define the meta path set meta_path, meta_path = Reshape (MS, N×num), set the context window size w, set the node embedding dimension size ed and the node embedding size es, define the current node embedding matrix E of size es×ed, the context node embedding matrix E′ of the current node, use the init.uniform() function in Pytorch to initialize E and E′; define the loss function variable L, initialize L = 0; define the current node embedding variable current_node_emb, define the positive sample node embedding variable nodes_emb, define the negative sample node embedding variable neg_nodes_emb, set the number of nodes sampled by negative samples num_sample, define the meta path count variable i, initialize i = 1; Step 2.3.2, define the meta-path node count variable c, initialize c = 1, define the current node number as current_node, the context node set of the current node as nodes, the context node number as nodes.num, the negative sample node set of the current node as neg_nodes, the negative sample node number as neg_nodes.num; define the positive sample loss score variable pos_score, define the negative sample loss score variable neg_score; Step 2.3.3, assign values ​​to the current node, the context node of the current node, and the negative sample node, current_node = meta_path[i][c], meta_path[i][c] is the cth node of the ith meta-path in meta_path, assign the nodes contained in the context window w of current_node to nodes, that is, nodes = meta_path[i][cw / 2:c+w / 2], and use the random selection function random.sample() to select from Randomly select num_sample nodes as negative samples and assign them to neg_nodes, that is, Step 2.3.4, assign a value to current_node_emb, current_node_emb = E[current_node], assign a value to nodes_emb, nodes_emb = E′[nodes.num], assign a value to neg_nodes_emb, neg_nodes_emb = E′[neg_nodes.num]; call the element-by-element multiplication function mul() in Pytorch to calculate the element-by-element multiplication result mul_out of current_node_emb and nodes_emb, mul_out = mul(current_node_emb, nodes_emb), use the activation function logsigmoid() to calculate the positive sample loss score and assign it to pos_score, the calculation formula is as follows: Use the batch matrix multiplication function bmm() in Pytorch to calculate bmm_out, bmm_out = bmm(current_node_emb, neg_nodes_emb), use the activation function logsigmoid() function to calculate the negative sample loss score, and assign it to neg_score. The calculation formula is as follows: Use the mean() function to average the sum of the positive sample loss score pos_score and the negative sample loss score neg_score, and assign it to L. The calculation formula is as follows: L=mean(pos_score,neg_score)=(pos_score+neg_score) / 2 Step 2.3.5, if c<len, c=c+1, according to the value of L, call the L.backward() function in the open source Pytorch to adjust the values ​​of E and E′, and go to step 2.3.3; Step 2.3.6, if i<N×num, i=i+1, initialize c=1, and go to step 2.3.3, otherwise output the current node embedding matrix E, if (G, Ms) is equal to (G1, Ms1), E1=E, if (G, Ms) is equal to (G2, Ms2), E2=E.

6. The method for locating leakage periods of a pipe network based on a continuous time graph according to claim 5 is characterized in that: The specific process of step 3 is as follows: Step 3.1, send G and E as input to the Neural Ordinary Differential Equation subnetwork NOde to obtain the continuous dynamic representation z of the node, z = NOde (G, E); Step 3.2, respectively set the input data feature dimension variable input_size, the hidden layer dimension variable hidden_size and the network layer number variable num_layers, and construct the feature prediction subnetwork structure LstmP according to the set variables, that is, LstmP = LSTM (input_size, hidden_size, num_layers), where LSTM () is an open source feature prediction network function in Pytorch, and the continuous dynamic representation z of the node is taken as input and sent to LstmP to obtain the predicted feature feature, that is, feature = LstmP (z); Step 3.3, take the predicted feature feature as input and send it to the classification subnetwork Cla to obtain the predicted category score score, that is, score = Cla (feature); Step 3.4, define the loss function LossP as LossP = BCELoss(score, label), where score and label are the predicted category score and the state of the measurement point obtained in step 3.3, respectively. BCELoss() is the open source binary cross entropy loss function in Pytorch. The calculation formula is as follows, and SN is the number of data in score:

7. The method for locating leakage periods of a pipe network based on a continuous time graph according to claim 6 is characterized in that: The specific process of step 4 is as follows: Step 4.1, set the training parameters of the leakage prediction network LeakP, the training parameters include batch data size batch_size, maximum iteration number epoch_max, minimum change value of loss function ΔMinlossP, learning rate initlr, network optimizer as optimizer, define the network training iteration number variable epoch, initialize it to 1, and define the loss function change value variable ΔLossP; Step 4.2: Send the graph G1 and the node embedding representation E1 of the graph G1 in step 3 to the network structure LeakP for training in batches according to the batch_size size, and obtain the predicted category score score1. The true value label label1 is the node state corresponding to G1. Calculate the loss value LossP epoch , LossP epoch =BCELoss(score1,label1), when epoch>1, calculate the loss function change value ΔLossP, ΔLossP=|LossP epoch -LossP epoch-1 |, where LossP epoch and LossP epoch-1 is the loss value of the epoch and epoch-1 generations; Step 4.3, if epoch<epoch_max or ΔLossP>ΔMinlossP, then epoch=epoch+1, use optimizer to reversely correct the weight coefficients of each network layer in the water pipe network leakage prediction network structure LeakP, and return to step 4.2; otherwise, end the training and output the network model ModelP.

8. The method for locating leakage periods of a pipe network based on a continuous time graph according to claim 7 is characterized in that: The specific process of step 5 is as follows: Step 5.1, send the graph G2 and its node embedding representation E2 into the network LeakP, and use the model ModelP to get the predicted category score score2=score; Step 5.2, use the average precision function average_precision_score() in the Python open source library sklearn as the main evaluation indicator of network performance, and get the evaluation result ap. The calculation formula is: ap=average_precision_score(score2,label2) Among them, the true value label label2 is the node state corresponding to G2

Images