Learning Distributed Geometric Koopman Operator for Sparse Networked Dynamical Systems
Abstract
The Koopman operator theory provides an alternative to studying nonlinear networked dynamical systems (NDS) by mapping the state space to an abstract higher dimensional space where the system evolution is linear.
The recent works show the application of graph neural networks (GNNs) to learn state to object-centric embedding and achieve centralized block-wise computation of the Koopman operator (KO) under additional assumptions on the underlying node properties and constraints on the KO structure.
However, the computational complexity of learning the Koopman operator increases for large NDS.
Moreover, the computational complexity increases in a combinatorial fashion with the increase in number of nodes.
The learning challenge is further ampliﬁed for sparse networks by two factors: 1) sample sparsity for learning the Koopman operator in the non-linear space, and 2) the dissimilarity in the dynamics of individual nodes or from one subgraph to another.
Our work aims to address these challenges by formulating the representation learning of NDS into a multi-agent paradigm and learning the
Koopman operator in a distributive manner.
Our theoretical results show that the proposed distributed computation of the geometric Koopman operator is beneﬁcial for sparse NDS, whereas for the fully connected systems this approach coincides with the centralized one.
The empirical study on a rope system, a network of oscillators, and a power grid show comparable and superior performance along with computational beneﬁts with the state-of-the-art methods.
Introduction
NDS represents an important class of dynamic networks where the state of the network is deﬁned by a vector of node-level properties in a geometrical manifold, and their evolution is governed by a set of differential equations.
Data-driven modeling of both spatio-temporal dependencies and evolution dynamics is essential to predict the response of the NDS to an external perturbation.
Surely, machinelearning approaches that explicitly recognize the interconnection structure of such systems or model the dynamical system-driven evolution of the network outperform initial deep learning approaches based on recurrent neural networks and its variants [1–5].
Deep learning approaches such as GNNs ﬁt into this paradigm by learning non-linear functions for each of the encoder-system model-decoder components [6–10].
Discovering the underlying physics of dynamical systems have intrigued control theory researcher for decades resulting into multiple sub-space based system identiﬁcation works [11–14].
Koopman operator theory [15, 16] is an approach for such model discovery where the core idea is to transform the observed state-space variables to the space of square-integrable functions, where a linear operator provides an exact representation of the underlying dynamical system and the spectrum of the operator encodes all the non-linear behaviors.
However, for computational purposes, ﬁnding ﬁnite-dimensional approximation of Koopman operator is challenging.
The key to computing the ﬁnite-dimensional Koopman operator is ﬁxing the lifting functions (observables) and existing approaches such as classical or extended dynamic mode decomposition [17, 18] use an a-priori choice of basis functions for lifting; however, this choice usually fails to generalize to more complex environments.
Instead, learning these transformations from the system trajectories themselves using deep neural networks (DNNs) have been shown to yield much richer invariant subspaces [19, 20].
Continuing the idea of lifting the non-linear state space into another space to learn linear transition dynamics, [21] proposed the use of a graph neural network as the encoder-decoder function.
While graph neural networks (GNN) [22] appears to be a natural approach for modeling the physics of networked systems, their ability to discover dynamic evolution models of large-scale networked systems is a nascent area of research [6, 7, 9, 23].
For NDS, where the number of system states increases with the number of nodes, the computational complexity of learning the Koopman operator also increases.
The topology of the network or its sparsity are typically not taken advantage of in the existing studies when learning observable functions or the Koopman operator.
In this work, we address the challenge of learning dissimilar dynamics in sparse networks by formulating the representation learning of networked dynamical systems into a multi-agent paradigm.
We refer to this approach as Distributed Koopman-GNN (DKGNN).
DKGNN is more suitable for sparse and large networked dynamical systems as the proposed distributed learning method yields superior computational efﬁciency compared to traditional methods.
We applied the GNNs to capture the distributed nature of the dynamical system behavior, transform the original state-space into the Koopman observable space, and subsequently use the network sparsity patterns to constrain the Koopman operator construction into a block-structured distributed representation along with theoretical guarantees.
Information-theoretic network clustering strategies were utilized for speciﬁc dynamic systems to capture the joint evolution of the clusters in a coarse-grained fashion resulting in further computational beneﬁts.
Please see Figure 1 for an illustration of the approach
[Figure]
[Table]
UzTFJMxHtKepRILqoN8fu8UnVllgOJE2ZIGzdXfEzkWWk9EZDsFNiO97M3E
[Table]
<latexit sha1_base64="1oscokho1/fX6FFWYfvAtKh251E=">AAACA3icbVDLSsNAFL2pr1pfUXe6GSxChVISKeqy4MaVVLAPaUOYTCft0MmDmYlQQsCNv+LGhSJu/Ql3/o3TNgutHrhwOOde7r3HizmTyrK+jMLS8srqWnG9tLG5tb1j7u61ZZQIQlsk4pHoelhSzkLaUkxx2o0FxYHHaccbX079zj0VkkXhrZrE1AnwMGQ+I1hpyTUP7tw0rqZ9gjm6zir2SVZFWvKrduaaZatmzYD+EjsnZcjRdM3P/iAiSUBDRTiWsmdbsXJSLBQjnGalfiJpjMkYD2lP0xAHVDrp7IcMHWtlgPxI6AoVmqk/J1IcSDkJPN0ZYDWSi95U/M/rJcq/cFIWxomiIZkv8hOOVISmgaABE5QoPtEEE8H0rYiMsMBE6dhKOgR78eW/pH1as89q9Zt6uVHJ4yjCIRxBBWw4hwZcQRNaQOABnuAFXo1H49l4M97nrQUjn9mHXzA+vgGRXpYd</latexit> Y p, N (1) ,Y f,
[Table]
<latexit sha1_base64="Wdt7IRHrtVq9EbFtMIadUMQkXnc=">AAACA3icbVDJSgNBEK1xjXEb9aaXxiBECGFGEvUY8OJJIphFkmHo6fQkTXoWunuEMAx48Ve8eFDEqz
[Table]
+eGQRtNNIBsSEKOajLo43DcJrNcZ2LzPAkOHVVfHLpL3V7Jwy22xWUwIIeD8DzsHQfNhnfQO3SAPiCCRugYnaIzNEEMJegn+oV+e5898IQn71Cv09S8Rf+Zd/sPG4rTlQ==</latexit> X f
In this work we compared with [21] which uses object-centric embeddings and learns a centralized
KO without considering the network structure.
We use advanced clustering methods that consider the dynamical evolution and exploit the resultant network structure to obtain a distributed KO.
Moreover, [21] deal with relatively small-sized systems, whereas we have extended it to large-scale NDS.
[20] uses a feed forward NN (MLP) to learn the observables that are state-inclusive and hence, don’t need to train a decoder separately, whereas, we use GNN-encoder and simultaneously train a GNN-decoder.
In [19], the authors also use generic neural network-based autoencoders for learning the Koopman observables.
Moreover, they assume that the eigenfunctions are the Koopman observables which is difﬁcult to ensure for pure data-driven learning of dynamical systems, and in this work, we propose a more general framework without this conservative assumption.
Contributions.
The main contributions of this paper are summarized as follows:
• We develop methods for learning distributed Koopman operator for large-scale networks, using system topology and network sparsity properties for NDS.
We present a system theoretic learning approach that can exploit the network connectivity structure via GNNs.
• We introduce information theoretic-based clustering strategies for sparse NDS to learn a coarsened structure and model the system using a hierarchical multi-agent paradigm.
• We present theoretical results on bounding the performance of the distributed geometric Koopman operator with respect to its centralized counterpart.
• We demonstrate that DKGNN yields two beneﬁts.
It improves the scalability of learning, and for sparse NDS with dissimilar dynamics across different parts of the network, it outperforms prediction performance of centralized approaches.
1.1 Related Work
Koopman operator theory The inﬁnite-dimensional Koopman operator is computationally intractable.
Several methods for identifying approximations of the inﬁnite-dimensional Koopman operator on a ﬁnite-dimensional space have recently been developed.
Most notable works include dynamic mode decomposition (DMD) [17, 24], extended DMD (EDMD) [18, 25], Hankel DMD [26], naturally structured DMD (NS-DMD) [27] and deep learning based DMD (deepDMD) [20, 28].
These methods are data-driven and one or more of these methods have been successfully applied for system identiﬁcation [17, 29] including system identiﬁcation from noisy data [30], data-driven observability/controllability gramians for nonlinear systems [31, 32], control design [33–35], datadriven causal inference in dynamical systems [36] and to identify persistence of excitation conditions for nonlinear systems [37].
[38] discusses distributed design of Koopman without control and using dictionary lifting functions.
Graph Neural Networks GNNs [22, 39] have found widespread use into every application involving non-Euclidean data [40].
Extending GNNs to model physics-driven processes gives rise to a new class of physics-inspired neural networks (PINN) [8–10].
A common theme is to model many-body interactions via a nearest-neighbor graph and then model the evolution of that graph [6, 7, 9].
However, addressing issues around compositionality [7, 23] and scalability becomes important as the foundation for PI(G)NN matures and we seek to model larger, multi-scale spatio-temporal interactions.
Moreover, applications such as molecular biology [20] and power grid [41] motivate the modeling of NDS where the graph structure is distinct from k-nearest neighbor graphs, with sparsity and connectivity that resemble small-world networks.
Recent works such as [21] provides a bridge that seeks to integrate
GNNs and Koopman operators to improve generalization ability and result in simpler linear transition dynamics.
However, their approach for learning Koopman state transitions and GNN embedding results in performance and scalability bottlenecks when system size increases.
Methodology 2.1 Networked Dynamical Systems and the Koopman Operator
Problem Statement : Consider a networked dynamical system (NDS) evolving over a network,
G =
( V , E ) .
Let the number of nodes and edges be n v and n e respectively and the governing equation for the NDS on
G is given by,
[Equation]
where x t ∈ M ⊆ R
n is the concatenated system state at time t and F : M → M is the discrete-time nonlinear transition mapping.
Our goal is to learn the system dynamics as expressed in equation (1) in a distributed approach combining the Koopman operator theory, graph neural networks and by leveraging on network sparsity properties.
Exploring the network structure, the n v nodes could be grouped to form n a agents where n a ≤ n v and results in a network denoted by G a =
( V a , E a ) with the state at any time t is partitioned as x t =
[ x (cid:62) t, 1 , . .
, x (cid:62) t,n a ] (cid:62) where for every α ∈ { 1 , . . . , n a } , the states x t,α belongs to agent α .
For completion, we mention that the number of nodes in
V a is equal to n a .
The motivation behind exploring the network structure is to develop models that will possess certain advantages when compared to the centrally learned models.
A method to identify G a from G for practical dynamical systems is discussed later in the paper.
Associated with the system (1) is a linear operator, namely the
Koopman operator U [42] which is deﬁned as follows.
Deﬁnition 1 (Koopman Operator (KO) [42]) .
Given any h ∈ L 2 ( M ) , the Koopman operator U : L 2 ( M ) →
L 2 ( M ) for the system (1) is deﬁned as [ U h ]( x ) =
h ( F ( x )) , where L 2 ( M ) is the space of square integrable functions on M .
Originally developed for autonomous systems, recently Koopman framework has been extended to systems with control [43, 44].
In this paper we consider a controlled dynamical system of the form:
[Equation]
) where G : M → R n × q is the input vector ﬁeld and u t ∈ R q denote the control input to the system at time t .
The Koopman operator associated with (2) is deﬁned on an extended state-space obtained as the product of the original state-space and the space of all control sequences, resulting in a controlafﬁne dynamical system on the extended state-space [43, 44].
In general, the Koopman operator is an inﬁnite-dimensional operator, but for computation purposes, a ﬁnite-dimensional approximation of the operator is constructed from the obtained time-series data as discussed below.
Consider the time-series data from a networked dynamical system as X =
[ xx. . .
x k ] ∈ R n × k , and the corresponding control inputs U = [ uu. . .
u k ] ∈ R q × k .
Deﬁne one time-step separated datasets, X p and X f from X as X p =
[ x 1 , x 2 , . . .
, x k − 1 ] , X f = [ x 2 , x 3 , . . .
, x k ] and let
S =
{ Ψ 1 , . . .
, Ψ m } be the choice of non-linear functions or observables where Ψ i
∈
L 2 ( R n , B , µ ) (where
B is the Borel σ algebra and µ denote the measure [42]) and Ψ i : R n → C .
Deﬁne a vector valued observable function Ψ : R n → C m as, Ψ( x ) :=
[Ψ 1 ( x ) Ψ 2 ( x ) · · · Ψ m ( x )] (cid:62) .
Then the following optimization problem which minimizes the least-squares cost yields the Koopman operator and the input matrix.
[Equation]
(3) where Y p =
Ψ( X p ) =
[Ψ( x 1 ) , · · · , Ψ( x k − 1 )] , Y f =
Ψ( X f ) =
[Ψ( x 2 ) , · · · , Ψ( x k )] , A ∈ R m × m is the ﬁnite dimensional approximation of the Koopman operator deﬁned on the space of observables and the matrix B ∈ R m × q is the input matrix.
The optimization problem (3) can be solved analytically and the approximate Koopman operator and the input matrix are given by [ A B ]
=
Y f
[ Y p
U ] † [43], where ( · ) † is the Moore-Penrose pseudo-inverse of a matrix.
Identifying the observable functions such that S is invariant under the action of the Koopman operator is challenging.
In this work, graph neural network-based mappings are used to construct the non-linear observable functions that satisfy the invariance by simultaneously learning the observables and the Koopman operator.
2.2 Graph Neural Network based Koopman Observables
Consider the network G with n v nodes where the time-series data at each node is supplemented with the node attribute capturing the nature of the node, denoted by the vector x v i where i = { 1 , 2 , . .
. , n v } .
For instance, we can characterize the generators in a electric power grid network with their inertia values.
Similarly, the designer can embed knowledge about the interaction between the agents using edge attributes, denoted as x e ij for the edge connecting nodes i and j .
We consider a graph neural network embedding to transition from the actual state-space to the lifted state-space using multiple compositional neural operations.
At the t th time-step, the node, and edge attributes are combined along with the state vectors of the agents which are compactly written as,
[Equation]
where the superscript k denotes the k th layer of the GNN, and functions f e ( · ) , and f v ( · ) are edge and node-level aggregation functions in a GNN architecture.
We use φ ( · ) to denote the multi-layer
GNN operation in a compact form.
The GNN can represent a complex nonlinear mapping that is not restricted by any limitation on the message-passing layers and can capture the inﬂuence coming from further nodes of the NDS.
We do not enforce any limitation on the inﬂuence propagation for GNN layers.
In summary, performing the lifting from the actual state space to the Koopman state space, we are using the GNN mappings in such a way that the identity of the nodes is still maintained, and thereafter we are using the agent-level information to group them to perform the distributed Koopman design.
Distributed Geometric Koopman Operator with Control Inputs
This section formally presents the computation of distributed geometric Koopman operator with control.
The (centralized) Koopman operator with control input for the system (2) is obtained by solving (3).
For the n a agent NDS, the resultant KO can be represented as n 2 a block matrices:
[Equation]
The dynamics of the α th agent have the dimension, m α , such that, (cid:80) n a α =1 m α = m .
It now follows that the block matrix A αβ ∈ R m α × m β denotes the transition of agent α with respect to β and the transition mapping for agent α is given by A α .
Similarly, the control input matrix is partitioned as B = blkdiag ( B 1 , B 2 , . . .
, B n a ) , where the matrix B α corresponds to input matrix of agent α ∈ { 1 , 2 , . . .
, n a } .
The objective of the distributed learning is to compute these block matrices in a distributed manner and form the geometric Koopman operator and the control input matrix for the complete NDS as opposed to directly solving the centralized optimization problem in Eq.
(3) without sacriﬁcing the performance with the distributed method.
There are two major advantages to this approach.
Firstly, if there is change in the local agent behavior, one can simply update the transition mapping corresponding to that agent and the agents dependent on it to learn the full system evolution.
Secondly, computational advantages can be obtained by incorporating parallel learning of each agent transition mapping and this approach is more appropriate for the sparse networks.
Please note our focus is to was to exploit the dynamical system properties to exploit distributed design recognizing the advances in the scalable matrix computations on any multi-core, GPU or distributed computing framework (such as Apache Spark) today [45–48].
By exploiting the topology of the network, the KO and the control input matrices are computed in a distributed manner.
As a consequence, if agent i is not a neighbor of agent j , that is, the dynamics of agent i is not affected by the dynamics of agent j , we make A ij = 0 .
Therefore, for every α ∈ { 1 , 2 , · · · , n a } , let ˆ A α be the transition mapping corresponding to the agent α , then the distributed Koopman is given by A D = (cid:2)
[Equation]
A
[Equation] [Equation]
For a sparse network, the distributed Koopman will be a sparse matrix irrespective of the centralized Koopman being either sparse or full (Figure 1).
Consider X p and X f be the one time-step separated time-series data on the state space, φ be the GNN-embedding that maps the state space data into an embedded space.
Then the time-series data on the embedded space for every agent can be expressed in terms of the neighbor and non-neighbor agents.
Remark 2.
The one time-step forwarded time-series data corresponding to agent α is given by
A α Y p = (cid:2)
A N ( α )
A N ( α ) (cid:3) (cid:20) Y p, N ( α ) Y p, N ( α ) (cid:21) , where
N ( α ) is the set of agents containing the neighbors of agent α and itself, N ( α ) is the set of agents who are non-neighbors of agent
α and the (rectangular) matrices, A N ( α ) and A N ( α ) are the transition mappings associated with the agent α .
Let R p,α , R f,α , and R u,α be the transformation matrices deﬁned in such a way that they remove zero rows of any matrix, D when pre-multiplied to the matrix, D .
Suppose if the matrix D has no zero rows then the transformation matrices are identity.
Proposition 3.
The centralized Koopman ( A, B ) learning problem described in Eq.
(3) can be expressed as a distributed Koopman ( A D , B D ) learning problem such that there exists matrices, ˆ A 1 , ˆ A 2 , . . .
, ˆ A n a , ˆ B 1 , ˆ B 2 , . . .
, ˆ B n a and the distributed Koopman operator is given by
A D = (cid:2) ˆ A (cid:62)ˆ A (cid:62)· · · ˆ A (cid:62) n a (cid:3) (cid:62) , input matrix is B D = blkdiag ( ˆ B 1 , ˆ B 2 , . . .
, ˆ B n a ) where for α ∈ { 1 , 2 , . .
. , n a } , ˆ A α =
A N ( α ) R p,α , ˆ B α = B α R u,α and A N ( α ) , B α are obtained as a solution to the optimization problem min
A N ( α ) ,B α (cid:107) Y f,α − A N ( α ) Y p, N ( α ) − B
α
U
α
(cid:107) 2 F .
From Proposition 3, with g t = φ ( x t ) , φ being the GNN encoder, the distributed geometric Koopman operator system with control input is given by g t
+1 =
A D g t + B D u t .
Corollary 4.
The distributed learning problem and the centralized learning problem yield the same
Koopman operator for a fully connected network.
The proofs for Proposition 3 and Corollary 4 are included in the appendix.
3.1 Training Distributed Geometric Koopman Model
[Figure]
The state space data is mapped to the GNNembedded space using the
GNN encoder φ .
To retrieve the actual state space data from the GNNembedded space, we use a decoding GNN operator such that, ˆ x t = ϕ
( g t ) .
The decoder ϕ ( · ) fol- lows similar GNN architecture as encoder however it maps from the lifted Koopman space to the original state space.
Looking into the agent-wise architectural detail, both encoder and decoder functions can be represented for the i th agent as φ i ( · ) , ϕ i ( · ) as shown in Figure 2 with the understanding that all the GNN functionalities take the neighbouring agent states and attributes as additional inputs.
This facilitates the computation of Koopman matrices in a distributed manner.
This architecture leads us to compute an auto-encoding loss, and a prediction loss over the time-steps t = 1 , 2 , . . .
, k − 1 , and are given as follows:
[Equation]
with total loss of L =
L ae + L p .
The algorithm will consist of two main update steps sequentially, one to update the Koopman and the control input matrix in a distributed manner for a ﬁxed set of GNN encoder and decoder parameters, and another to update GNN weights with a learned distributed geometric Koopman representation.
Algorithm 1 shows the computational steps where the function DistributedKoopmanMatrices ( · ) presents the distributed Koopman state and input matrices, A D , B D .
Thereafter the Main ( · ) function runs the update of the distributed Koopman matrices and the GNN parameters sequentially for each epoch as shown in steps 15 and 16 .
For simplicity of representation in the algorithm, we use the compact notations φ ( · ) and ϕ ( · ) instead of agent-wise representation as in Figure 2.
3.2 Multi-Agent Network Construction via Information Transfer-based Clustering
Mapping of nodes in an NDS to nodes in an agent network is a core aspect for our proposed method.
We use an information-theoretic clustering method [49] that exploits both the adjacency matrix structure as well as dynamical properties of the network for this task.
For a dynamical system, the deﬁnition of information transfer [50] from a dynamical state x t,i to another state x t,j is based on the intuition that the total entropy of a dynamical state x t,j is equal to the sum of the entropy of x t,j when another state x t,i is not present in the dynamics and the amount of entropy transferred from x t,i to x t,j .
In particular, for a discrete-time dynamical system x t +1 =
F
( x t ) , where x t =
[ x (cid:62) t,x (cid:62) t, 2 ] (cid:62) and F =
[ f (cid:62)f (cid:62) 2 ] (cid:62) , the one-step information transfer from x t, 1 to x t, 2 , as the system evolves from time-step t to t + 1 is [ T x t, 1 → x t, 2 ] t +1 t
= H ( x t +1 , 2 | x t, 2 ) − H (cid:54) x t, 1 ( x t +1 , 2 | x t, 2 ) .
Here, H ( x t +1 , 2 | x t, 2 ) is the conditional Shannon entropy of x t, 2 for the original system and H (cid:54) x t, 1 ( x t +1 , 2 | x t, 2 ) is the conditional entropy of x t, 2 for the system where x t, 1 has been held frozen from from time t to time
1: function D ISTRIBUTED K OOPMAN M ATRICES ( X p , X f , U, φ ) 2:
Map the time-series data to the GNN-embedded space using φ as follows:
Y p =
φ ( X p ) =
[ φ ( x 1 ) , φ ( x 2 ) , · · · , φ ( x k − 1 )] , Y f
= φ ( X f ) =
[ φ ( x 2 ) , φ ( x 3 ) , · · · , φ ( x k )] 3: for α = 1 , 2 , . . .
, n a do 4:
Deﬁne the transformation matrices for agent α as:
T p,α := blkdiag ( ae 1 , . .
, ae n a ) , T f,α :=
blkdiag ( ee 1 , . .
, ee n a ) ,
T u,α := blkdiag ( eu 1 , . . . , eu n a ) , where ae i =
( a α + e α ) i ⊗ I m i , ee i =
( e α ) i ⊗ I m i , eu i =
( e α ) i ⊗ I
q i , where ⊗ is the Kronecker product.
Compute Y f,α , Y p, N ( α ) , U α associated with agent α as
Y f,α = R f,
[Equation]
T f,
[Equation]
Y f , Y p, N ( α )
=
R p,
[Equation]
T p,α Y p , U
[Equation]
= R u,
[Equation]
T u,α U 6:
Solve the optimization problem: min A N ( α ) ,B α (cid:107) Y f,α − A N ( α ) Y p, N ( α ) − B α U α (cid:107) 2 F 7:
Compute ˆ A α =
A N ( α ) R p,α and ˆ B α = B α R u,α 8: end for 9: return :
A D = (cid:2) ˆ A (cid:62)ˆ A (cid:62)· · · ˆ A (cid:62) n (cid:3) (cid:62) , B D = blkdiag ( ˆ B 1 , ˆ B 2 , . . .
, ˆ B n ) .
10: end function 11: function M AIN () 12:
Given state ( X p , X f ) and input ( U ) time-series data from a N a agent network 13:
Initialize the GNN-based encoder ( φ ) and decoder ( ϕ ) network 14: for epochs = 1,2, . .
, N epoch do 15:
Koopman Update: Run ( A D , B D ) =
DistributedKoopmanMatrices( X p , X f , U, φ ) 16:
GNN Update: Compute , L =
L p + L ae , and backpropagate L to update φ, ϕ parameters.
17: end for 18: return: Updated A D , B D , φ, and , ϕ .
19: end function t + 1 .
Note that the information transfer is in general asymmetric and characterize the inﬂuence of one state on any other state.
Furthermore, for stable dynamical system the information transfer between the states always settle to a steady state value.
We use this information transfer measure to deﬁne an inﬂuence graph for the NDS studied in this paper.
We form a directed weighted graph with the states as the nodes and introduce an edge from x t, 1 to x t, 2 iff the information transfer from x t, 1 to x t, 2 is non-zero.
Moreover, the edge-weight for the edge x t, 1 → x t, 2 is exp( −| T x t,
→ x t, 2 | /β )
[49], where | T x t, 1 → x t, 2 | is the absolute value of the steady-state information transfer from x t, 1 to x t, 2 (we assume stable dynamics) and β > 0 is a parameter similar to temperature in a Gibbs’ distribution.
Applying this to a dynamical system, a directed weighted graph is computed based on the information transfer and is clustered accordingly to obtain a multi-agent network.
Figure 3 uses a power network example to illustrate how the nodal attributes from different clusters demonstrate different transient evolution trajectories.
Due to space constraints, we do not discuss the details of the data-driven computation of the information transfer from time-series data and we refer the reader to [51] for more details.
Numerical Experiments
In this section, we aim to answer the following research questions through our experiments: (RQ1)
How does the distributed GNN-based Koopman (DKGNN) model’s performance compare with other state-of-the-art approaches such as centralized GNN-based Koopman (CKGNN) [21] and graph neural network approaches for modeling multi-body interactions [52] (RQ2) How do various dynamical system properties such as sparsity, spatio-temporal correlation, and damping properties inﬂuence the performance boost from the distributed algorithm?
(RQ3)
What is the potential for distributed approaches for scaling to larger NDS in the future?
The code for the experiments will be made online in the paper website [53] 1 .
Environments.
We perform numerical experiments on three different data-sets.
The baseline rope system introduced in [7] consists of a set of six objects connected via a line graph.
The second dataset is a network of oscillators which is a prototype used for modelling various real-world systems in biology [54, 55], synchronization of ﬁreﬂies [56], superconducting Josephson junctions [57] etc.
We consider a sparse network of oscillators consisting of 50 agents where the dynamics at each oscillator are governed by a second-order swing differential equation.
The network density for this network is 0 .
Our third dataset studies a signiﬁcantly larger and complex system of immense practical importance.
Power grid networks [58] are complex infrastructures that are essential for every aspect of modern life.
The ability to predict transient behavior in such networks is key to the prevention of cascading failures and effective integration of renewable energy sources [59, 60].
We consider the IEEE 68 -bus power grid model [61] that represents the interconnections of New England Test
System and New York Power System.
This is a sparse, heterogeneous network with a network density 0 . 0378 ; the network has 68-nodes, with 16-nodes representing generators and the rest being loads.
The ability to accurately predict changes in voltage and frequency is key to capturing the tendency of a power grid to move towards undesired oscillatory regions.
Transient stability simulations for the grid datasets are performed by the Power Systems Toolbox [62].
We provide more details on the datasets and experiments in the supplementary.
Baselines and Implementation Details.
We baseline our method against centralized GNN-based
Koopman (CKGNN) [21] and propagation network (PN), a GNN-based approach [52] using their available implementations.
We evaluate all models on the trajectory prediction task where we predict [Table] the node-level time-series measurements for each of these environments that represent velocity of objects (rope), angles and frequencies of oscillators, and frequency measurements for the power grid.
For PN, we slightly modify the prediction workﬂow from the author-provided implementation to make sure that we always feed the PN with the predicted signal values except for the initial signal input for the prediction task in consecutive time steps.
Our methods are implemented on the Pytorch framework [63] and run on an NVIDIA A100 GPU.
For PN baseline, we used 3 propagation steps with 32 as the batch size.
The dimensions of the hidden layer of relation encoder, object encoder, and propagation effect are set as follows, for PN
we use 150, 100, and 100, respectively for all the cases, for the rope system with CKGNN and DKGNN, we have used 120, 100, and 100, and for the oscillator and grid example with both CKGNN and DKGNN, these are set to be 60 .
The models are trained with Adam based stochastic gradient descent optimizer with a learning rate of 10 − 5 .
For rope, we consider 10 , 000 episodes with 100 time-steps and training-testing division of 90% − 10% , and batch size of 8 episodes.
We consider the oscillator node state trajectories of 100 time-steps and trained with a total of 9000 time-steps, batch size of 10 trajectories, and have tested with three different testing conﬁgurations and predicting for each trajectory of 100 time-steps.
Considering the power grid network, we have considered 50 time-steps to capture the initial fast transients and train the model with 1100 time steps with a batch size of 5 episodes along with testing in ﬁve different scenarios with multiple testing trajectories each with 50 time steps.
Next, RQ1 is a general discussion with respect to varying sparsity degrees, and then RQ2 is focusing more on the effect of dynamical system parameters.
RQ1: Prediction performance analysis.
Figure 4 shows that DKGNN outperforms other baselines in trajectory prediction.
Table 1 reports the mean square error (MSE) averaged over all timesteps and over all states in the test trajectory dataset.
The rope system is minimally sparse with a network density of 0 .
33 , thereby resulting in improved predictive performance for the DKGNN when compared to KGNN.
The improvements are signiﬁcantly pronounced for sparser and larger network models of oscillators (network density 0 . 0408 ) and power grid (network density 0 . 0378 ).
The superior prediction performance over considerable trajectory time-steps (as demonstrated in
Figure 4 second row) substantiates the applicability of DKGNN for sparse NDS.
RQ2.1 Performance with respect to varying NDS properties.
The damping parameter provides us with a way to systematically study the response of an NDS to an input.
Damping is a property of the NDS, and not a property of perturbations to the system.
Lower damping implies that the system will take longer to converge to a steady state.
We hypothesize that the introduction of input perturbations of the same magnitude at different nodes will evoke different responses depending on the connectivity structure around these nodes.
For the oscillator network, we consider testing scenarios with disturbances created at high damping nodes ( > 13 in appropriate units) and low damping nodes ( < 1 ).
We consider ﬁve different conﬁgurations for the power grid network.
Three of the scenarios are based on the perturbations in the loads which are respectively one-hop, two-hop, and three-hop away from the generator buses, and two other load disturbance scenarios are considered at locations with high and low degrees of connectivity.
The IEEE-68 bus grid network speciﬁcations also include an area-wise partitioning that is done based on eigenvalue separation and extensive application of domain-knowledge [64].
We observe DKGNN approach is able to produce better prediction performance with all of these scenarios ( 81 , 79 , 74 , 76 , 74% improvements with area-wise partitioning, and 77 , 76 , 66 , 84 , 69% improvements with information-theoretic partitioning for the ﬁve cases listed in Table I from top to bottom with respect to the centralized approach).
The second and third columns of Figure 4 correspond to the oscillator (where the disturbance is at high-damping nodes), and the power grid (where the disturbance is at high-degree buses), respectively, where both of them show the superior performance of DKGNN to the baselines.
RQ2.2 Performance with respect to sparse NDS clustering.
This subsection reports our validation of the effectiveness of the information-theoretic clustering based agent structure discovery using the power grid network.
We compare our IT-based clustering with respect to the grid’s standard area-wise partitioning as discussed previously.
Both the expert-driven partitioning and our clustering driven partitioning divide the grid into 5 clusters and yields a 5-agent network to use for the training.
Table
I and Figure 4 show that DKGNN exploits the localized dominant dynamics and yields superior predictive performance when compared to the centralized approaches such as CKGNN and PN.
RQ3.
Computational Scalability.
We compare the run time of our DKGNN with the corresponding centralized one, KGNN.
Let τ ( φ + A D + ϕ ) denote the combined computation time for GNN encoder ( φ ), distributed Koopman ( A D ) and the GNN decoder ( ϕ ).
[Figure]
Similarly, τ ( φ + A + ϕ ) denote the computation for
KGNN where the centralized Koopman ( A ) is obtained.
The reduction in total run-time ( % ) is computed as τ ( KGNN )
[Equation]
× 100 .
From Figure 5, it is clear there is a signiﬁcant reduction in run time for the larger and sparser networks of oscillator (50 nodes with network density = 0.041), and power grid ( 68 nodes, 5 clustered areas and network density of 0.038).
These examples see a considerable performance boost ( 45 .
63% for oscillator and 32% for power grid)
owing to capturing the dominant localized dynamic behavior.
The rope which is a smaller system with 6 nodes and single excitation (at the top) shows only slightly improvement in runtime (5%), owing to high network density (0.33).
Conclusions
We present a geometric deep learning based distributed Koopman operator (DKGNN) framework that can exploit dynamical system sparsity to improve computational scalability.
Our results on bounding the DKGNN performance with respect to its centralized counterpart provides a rigorous theoretical foundation.
Extensive empirical studies on large NDS of oscillators and practical power grid models show the effectiveness of DKGNN design with respect to varying degree of NDS dynamical properties and sparsity patterns.
Future research will look into incorporating attention capability to the distributed design, investigating the robustness aspects in presence of physical or adversarial faults and perform control designs on the learned distributed dynamical model.
Acknowledgement
This work was supported in part by the Paciﬁc Northwest National Laboratory (PNNL) through the
Battelle Memorial Institute for the U.S. Department of Energy under Contract DE-AC05-76RL01830, and in part by the Data Model Convergence (DMC) Initiative at PNNL.
Appendix
Notations.
The vectors a j , e j respectively denote the j th column of the adjacency matrix, Adj and a vector of standard basis in R m .
The notation, ( a j ) i denotes the i th entry of the column vector a j .
I m denote the identity matrix of size m .
The Kronecker product is denoted by ⊗ .
The block diagonal matrix with block matrices, M 1 , M 2 , . . .
, M (cid:96) is denoted by blkdiag ( M 1 , M 2 , . . .
, M (cid:96) ) .
Suppose D = (cid:2) D (cid:62)
D
[Equation]
D
[Equation]
(cid:3) (cid:62) where D 1 , D 2 , . . .
, D (cid:96) are wide rectangular matrices.
Then from the deﬁnition of the Frobenius norm, we have,
[Equation]
If D 1 and D 2 are two matrices, then
[Equation]
S
[Equation]
where trace ( D (cid:62) 1 D 2 ) denote the Frobenius inner product of the matrices D 1 and D 2 .
For any matrix
D , the Moore-Penrose inverse is denoted by D † .
7.1 Proof of Proposition
Proof.
Consider the the centralized learning problem described in Eq.
M3 (where the notation ‘M’ indicates the equation is from the main manuscript).
This problem is now rewritten with respect to each agent as follows.
[Equation]
where the last step follows by noticing that A N ( α ) = 0 since the agent α is not connected to the agents in N ( α ) .
In the above steps, the computation of Y f,α and Y p, N ( α ) involves computing the transformation matrices T
[Equation]
,α , R p,α which are computed under the knowledge of the network topology.
Finally, we obtain,
[Equation]
For every α ∈ { 1 , 2 , . . . , n a } , A N ( α ) , B α can now be obtained analytically as (cid:2)
A N ( α )
B α
[Equation]
=
Y f,α (cid:2)
Y p, N ( α )
U α (cid:3) † and the transition mapping corresponding to the agent α is given by
[Equation]
for α ∈ { 1 , 2 , . . .
, n a } .
Finally the distributed Koopman is given by A D = (cid:2)
ˆ A (cid:62)ˆ A (cid:62)· · · ˆ A (cid:62) n a (cid:3) (cid:62) , input matrix is
B D = blkdiag ( B 1 , B 2 , . . .
, B n a ) .
Hence the proof.
7.2 Proof of Corollary
Proof.
The proof follows by noticing that in a fully connected network, for any agent α , the corresponding non-neighbors set, N ( α ) is empty.
7.3 More Details on the Numerical Studies
The network topologies of the three example systems are given in Figure 7.
We follow the physics simulation engine provided by [21] for generating the data for the rope example, and follow the baseline node and edge attributes for the objects and connecting edges.
For the oscillator network, each of the individual node dynamics follows a second order differential equation.
The overall dynamics is represented as:
[Equation]
where θ ∈
R n v , ˙ θ ∈
R n v are the angles and frequencies of the oscillator.
The diagonal matrices M and D contain inertia and damping of the nodes.
The coupling of the nodes are captured by the Laplacian L with their strengths represented by β . 0 n v
and I n v denote the zero and identity matrices of size n v .
For the oscillators we have created one-hot vector for node attributes.
We have divided the nodes into low inertia ( < 3 in appropriate units), medium inertia ( > 3 , but < 8 ), and considerably high inertia ( > 8 ), thereby creating 3 − dimensional node attribute vectors.
The edge attributes are also one-hot vectors with 6 different types.
Based on inertia, these types are: low-low, high-high, medium-medium, and un-directed low-medium, medium-high, and low-high.
The IEEE benchmark 68 -bus powergrid model is simulated with detailed dynamics following the power system toolbox [62].
Our prediction models are learned for fast transient frequencies.
The node attributes are designed similarly as the oscillator studies, however, here the nodes are physical powergrid buses which are classiﬁed as generator buses, load buses, and buses without any loads or generators (let us call it none), thereby creating 3 − dimensional one-hot vectors.
The edges connecting buses represent powergrid transmission lines, thereby, edge attributes are characterized as generator-load, load-none, and generator-none connections, resulting in a 3 − dimensional one-hot vectors.
The network density of the systems are used to characterize the sparsity which is deﬁned as the ratio between the number of edges to the maximum number of possible edges.
We present few examples of the prediction performance of the DKGNN model for predicting the dynamic system behaviours over time steps.
Figure 6 shows the the positions and velocities of the rope objects 2 , 4 and 6 for the predicted performance with respect to the actual physics simulations.
Figure 8 shows an example of prediction performance for the network of oscillators at nodes 12 , 23 , and 45 .
Prediction performance for the powergrid example is shown in Figure 9 with informationtheoretic clustering used for the DKGNN for buses 20 , 54 , and 60 .
These ﬁgures show satisfactory performance for the distributed geometric Koopman models for all the networked dynamic system examples.