Year: 2020

Abstract:
Finding an embedding space for a linear approximation of a nonlinear dynamical system enables efficient system identification and control synthesis. The Koopman operator theory lays the foundation for identifying the nonlinear-to-linear coordinate transformations with data-driven methods. Recently, researchers have proposed to use deep neural networks as a more expressive class of basis functions for calculating the Koopman operators. These approaches, however, assume a fixed dimensional state space; they are therefore not applicable to scenarios with a variable number of objects. In this paper, we propose to learn compositional Koopman operators, using graph neural networks to encode the state into objectcentric embeddings and using a block-wise linear transition matrix to regularize the shared structure across objects. The learned dynamics can quickly adapt to new environments of unknown physical parameters and produce control signals to achieve a specified goal. Our experiments on manipulating ropes and controlling soft robots show that the proposed method has better efficiency and generalization ability than existing baselines.

heading: 1 INTRODUCTION
text: Simulating and controlling complex dynamical systems, such as ropes or soft robots, relies on two key features of the dynamics model: first, it needs to be efficient for system identification and motor control; second, it needs to be generalizable to a complex, constantly evolving environments.
In practice, computational models for complex, nonlinear dynamical systems are often not efficient enough for real-time control (Mayne, 2000). The Koopman operator theory suggests that identifying nonlinear-to-linear coordinate transformations allows efficient linear approximation of nonlinear systems (Williams et al., 2015; Mauroy & Goncalves, 2016). Fast as they are, however, existing papers on Koopman operators focus on a single dynamical system, making it hard to generalize to cases where there are a variable number of components.
In contrast, recent advances in approximating dynamics models with deep nets have demonstrated its power in characterizing complex, generic environments. In particular, a few recent papers have explored the use of graph nets in dynamics modeling, taking into account the state of each object as well as their interactions. This allows their models to generalize to scenarios with a variable number of objects (Battaglia et al., 2016; Chang et al., 2017). Despite their strong generalization power, they are not as efficient in system identification and control, because deep nets are heavily over-parameterized, making optimization time-consuming and sample-inefficient.
In this paper, we propose compositional Koopman operators, integrating Koopman operators with graph networks for generalizable and efficient dynamics modeling. We build on the idea of encoding states into object-centric embeddings with graph neural networks, which ensures generalization power. But instead of using over-parameterized neural nets to model state transition, we identify the Koopman matrix and control matrix from data as a linear approximation of the nonlinear dynamical system. The linear approximation allows efficient system identification and control synthesis.
The main challenge of extending Koopman theory to multi-object systems is scalability. The number of parameters in the Koopman matrix scales quadratically with the number of objects, which harms the learning efficiency and leads to overfitting. To tackle this issue, we exploit the structure of the
∗indicates equal contributions. Our project page: http://koopman.csail.mit.edu
underlying system and use the same block-wise Koopman sub-matrix for object pairs of the same relation. This significantly reduces the number of parameters that need to be identified by making it independent of the size of the system.
Our experiments include simulating and controlling ropes of variable lengths and soft robots of different shapes. The compositional Koopman operators are significantly more accurate than the state-of-the-art learned physics engines (Battaglia et al., 2016; Li et al., 2019b), and faster when adapting to new environments of unknown physical parameters. Our method also outperforms vanilla deep Koopman methods (Lusch et al., 2018; Morton et al., 2018) and Koopman models with manually-designed basis functions, which shows the advantages of using a structured Koopman matrix and graph neural networks. Please see our project page for demonstrating videos.

heading: 2 RELATED WORK
text: Koopman operators. The Koopman operator formalism of dynamical systems is rooted in the seminal works of Koopman and Von Neumann in the early 1930s (Koopman, 1931; Koopman & Neumann, 1932). The core idea is to map the state of a nonlinear dynamical system to an embedding space, over which we can linearly propagate into the future. Researchers have proposed various algorithms to explore the Koopman spectral properties from data. A large portion of them are in the class of dynamic mode decomposition (DMD) (Rowley et al., 2009; Schmid, 2010; Tu et al., 2014; Williams et al., 2015; Arbabi & Mezic, 2017). The linear representation will enable efficient prediction, estimation, and control using tools from linear dynamical systems (Williams et al., 2016; Proctor et al., 2018; Mauroy & Goncalves, 2019; Korda & Mezić, 2018). People have been using hand-designed Koopman observables for various modeling and control tasks (Brunton et al., 2016; Kaiser et al., 2017; Abraham et al., 2017; Bruder et al., 2019b; Arbabi et al., 2018). Some recent works have applied the method to the real world and successfully control soft robots with great precision (Bruder et al., 2019a; Mamakoukas et al., 2019).
However, hand-crafted basis functions sometimes fail to generalize to more complex environments. Learning these functions from data using neural nets turns out to generate a more expressive invariant subspace (Lusch et al., 2018; Takeishi et al., 2017) and has achieved successes in fluid control (Morton et al., 2018). Morton et al. (2019) has also extended the framework to account for uncertainty in the system by inferring a distribution over observations. Our model differs by explicitly modeling the compositionality of the underlying system with graph networks. It generalizes better to environments of a variable number of objects or soft robots of different shapes.
Learning-based physical simulators. Battaglia et al. (2016) and Chang et al. (2017) first explored learning a simulator from data by approximating object interactions with neural networks. These models are no longer bounded to hard-coded physical rules, and can adapt to scenarios where the underlying physics is unknown. Please refer to Battaglia et al. (2018) for a full review. Recently, Mrowca et al. (2018) and Li et al. (2019a) extended these models to approximate particle dynamics of deformable shapes and fluids. Flexible as they are, these models become less efficient during model adaptation in complex scenarios, because the optimization of neural networks usually needs a lot of
samples and compute, which limits its use in an online setting. Nagabandi et al. (2019a;b) proposed to use meta-learning for online adaptation, and have shown to be effective in simulated robots and a real legged millirobot. However, it is not clear whether their methods can generalize to systems with variable numbers of instances. The use of graph nets and Koopman operators in our model allows better generalization ability and enables efficient system identification as we only need to identify the transition matrices, which is essentially a least-square problem and can be solved very efficiently.
People have also used the learned physics engines for planning and control. Many previous papers in this direction learn a latent dynamics model together with a policy in a model-based reinforcement learning setup (Racanière et al., 2017; Hamrick et al., 2017; Pascanu et al., 2017; Hafner et al., 2019); a few alternatives use the learned model in model-predictive control (MPC) (Sanchez-Gonzalez et al., 2018; Li et al., 2019b; Janner et al., 2019). In this paper, we leverage the fact that the embeddings in the Koopman space are propagating linearly through time, which allows us to formulate the control problem as quadratic programming and optimize the control signals much more efficiently.

heading: 3 APPROACH
text: We first present the basics of Koopman operators: for a nonlinear dynamical system, the Koopman observation functions can map the state space to an embedding space where the dynamics become linear. We then discuss the compositional nature of physical systems and show how graph networks can be used to capture the compositionality.

heading: 3.1 THE KOOPMAN OPERATORS
text: Let xt ∈ X ⊂ Rn be the state vector for the system at time step t. We consider a non-linear discrete-time dynamical system described by xt+1 = F (xt). The Koopman operator (Koopman, 1931), denoted as K : F → F , is a linear transformation defined by Kg , g ◦ F , where F is the collection of all functions (also referred to as observables) that form an infinite-dimensional Hilbert space. For every function g : X → R belonging to F , we have
(Kg)(xt) = g(F (xt)) = g(xt+1), (1)
making the function space F invariant under the action of the Koopman operator. Although the theory guarantees the existence of the Koopman operator, its use in practice is limited by its infinite dimensionality. Most often, we assume there is an invariant subspace G of the Koopman operator. It spans by a set of base observation functions {g1, · · · , gm} and satisfies that Kg ∈ G for any g ∈ G. With a slightly abuse of the notation, we now use g(xt) : Rn → Rm to represent [g1(x
t), · · · , gm(xt)]T . By constraining the Koopman operator on this invariant subspace, we get a finite-dimensional linear operator K ∈ Rm×m that we refer as the Koopman matrix. Traditionally, people hand-craft base observation functions from the knowledge of underlying physics. The system identification problem is then reduced to finding the Koopman matrix K, which can be solved by linear regression given historical data of the system. Recently, researchers have also explored data-driven methods that automatically find the Koopman invariant subspace via representing the base observation functions g(x) via deep neural networks.
Although the original Koopman theory does not consider the system with external control inputs, researchers have found that linearly injecting control signals to the Koopman observation space can give us good numerical performance (Brunton et al., 2016; Bruder et al., 2019a). Mathematically, considering a dynamical system, xt+1 = F (xt,ut), with an external control input ut, we aim to find the Koopman observation functions and the linear dynamics model in the form of
g(xt+1) = Kg(xt) + Lut, (2)
where the coefficient matrix L is referred to as the control matrix.

heading: 3.2 COMPOSITIONAL KOOPMAN OPERATORS
text: The dynamics of a physical system are governed by physical rules, which are usually shared across different subcomponents in the system. Explicitly modeling such compositionality enables more efficient system identification and control synthesis and provides better generalization ability.
Motivating example. Consider a system with N balls moving in a 2D plane, each pair connected by a linear spring. Assume all balls have mass 1 and all springs share the same stiffness coefficient k. We denote the i’s ball’s position as (xi, yi) and its velocity as (ẋi, ẏi). For ball i, equation 3 describes its dynamics, where xi , [xi, yi, ẋi, ẏi]T denotes ball i’s state:
ẋi = ẋiẏiẍi ÿi  =  ẋi ẏi∑N j=1 k(xj − xi)∑N j=1 k(yj − yi)  =  0 0 1 00 0 0 1k −Nk 0 0 0 0 k −Nk 0 0  ︸ ︷︷ ︸
,A
xiyiẋi ẏi +∑ j 6=i 0 0 0 00 0 0 0k 0 0 0 0 k 0 0  ︸ ︷︷ ︸
,B
xjyjẋj ẏj  . (3)
We can represent the state of the whole system using the union of every ball’s state, where x = [x1, · · · ,xN ]T . Then the transition matrix is essentially a block matrix, where the matrix parameters are shared among the diagonal or off-diagonal blocks as shown in equation 4:
ẋ =  ẋ1 ẋ2 ...
ẋN
 =  A B · · · B B A · · · B ... ... . . .
... B B · · · A
  x1 x2 ...
xN  . (4) Based on the linear spring system, we make three observations for multi-object systems.
• The system state is composed of the state of each individual object. The dimension of the whole system scales linearly with the number of objects. We formulate the system state by concatenating the state of every object, corresponding to an object-centric state representation.
• The transition matrix has a block-wise substructure. After assuming an object-centric state representation, the transition matrix naturally has a block-wise structure as shown in equation 4.
• The same physical interactions share the same transition block. The blocks in the transition matrix encode actual interactions and generalize across systems. A and B govern the dynamics of the linear spring system, and are shared by systems with a different number of objects.
These observations inspire us to exploit the structure of multi-object systems, instead of learning separate models for systems that contains different numbers of balls.
Compositional Koopman operators. Motivated by the linear spring system, we want to inject a good inductive bias to incorporate compositionality when applying the Koopman theory. This allows better generalization ability and more efficient system identification and better controller design. Figure 1 shows an overview of our model.
Considering a system with N objects, we denote xt as the system state at time t and xti is the state of the i’th object. We further denote gt , g(xt) as the embedding of the state in the Koopman invariant space. In the rest of the paper, we call gt the Koopman embedding. Based on the observation we made in the case of linear spring system, we propose the following assumptions on the compositional structure of the Koopman embedding and the Koopman matrix.
• The Koopman embedding of the system is composed of the Koopman embedding of every objects. Similar to the decomposition in the state space, we assume the Koopman embedding can be divided into object-centric sub-embeddings, i.e. gt ∈ RNm denoting the concatenation of gt1, · · · , gtN , where we use gti = gi(xt) ∈ Rm as the Koopman embedding for the i’th object. • The Koopman matrix has a block-wise structure. It is natural to think the Koopman matrix is composed of block matrices after assuming an object-centric Koopman embeddings. In equation 5, Kij ∈ Rm×m and Lij ∈ Rm×l are blocks of the Koopman matrix and the control matrix, where l is the dimension of the action for each object and ut ∈ RNl is the concatenation of ut1, · · · ,utN denoting the total control signal at time t:g t+1 1 ...
gt+1N
 = K11 · · · K1N... . . . ... KN1 · · · KNN  g t 1 ... gtN + L11 · · · L1N... . . . ... LN1 · · · LNN  u t 1 ... utN  . (5)
As we have seen in the case of linear spring system, those matrix blocks are not independent, but some of them share the same set of values.
• The same physical interactions shall share the same transition block. The equivalence between the blocks should reflect the equivalence of the interactions, where we use the same transition sub-matrix for object pairs of the same relation. For example, if the system is composed of N identical objects interacting with the same relation, then, by symmetry, all the diagonal blocks should be the same, while all the off-diagonal blocks should also be the same. The repetitive structure allows us to efficiently identify the values using least squares regression.

heading: 3.3 LEARNING THE KOOPMAN EMBEDDINGS USING GRAPH NEURAL NETWORKS
text: For a physical system that contains N objects, we represent the system at time t using a directed graph Gt = (Ot, R), where vertices Ot = {oti}Ni=1 represent objects and edges R = {rk}N 2 k=1 represent pair-wise relations. Specifically, oti = (x t i,a o i ) , where x t i is the state of object i and aoi is a one-hot vector indicating the object type, e.g., fixed or movable. For relation, we have rk = (uk, vk,a r k), 1 ≤ uk, vk ≤ N , where uk and vk are integers denoting the end points of this directed edge, and ark is a one-hot vector denoting the type of the relation k.
We use a graph neural network similar to Interaction Networks (IN) (Battaglia et al., 2016) to generate object-centric Koopman embeddings. IN defines an object function fO and a relation function fR to model objects and their relations in a compositional way. Similar to a message passing procedure, we calculate the edge effect etk = fR(o t uk ,otvk ,a r k)k=1...N2 , and node effect
gti = fO(o t i, ∑ k∈Ni e t k)i=1...N , where Ni denotes the relations that point to the object i and {gti} are the derived Koopman embeddings. We use this graph neural network, denoted as φ, to represent our Koopman observation function.
System identification. For a sequence of observations x̃ = [x1, · · · ,xT ] from time 1 to time T , we first map them to the Koopman space as g̃ = [g1, · · · , gT ] using the graph encoder φ, where gt = φ(xt). We use gi:j to denote the sub-sequence [gi, · · · , gj ]. To identify the Koopman matrix, we solve the linear regression minK ‖Kg1:T−1 − g2:T ‖2. As a result, K = g2:T (g1:T−1)† will asymptotically approach the Koopman operator K with an increasing T . For cases where there are control inputs ũ = [u1, · · · ,uT−1], the calculation of the Koopman matrix and the control matrix is essentially solving a least squares problem w.r.t. the objective
min K,L ‖Kg1:T−1 + Lũ− g2:T ‖2. (6)
As we mentioned in the Section 3.2, the dimension of the Koopman space is linear to the number of objects in the system, i.e., g̃ ∈ RNm×T and K ∈ RNm×Nm. If we do not enforce any structure on the Koopman matrix K, we will have to identify N2m2 parameters. Instead, we can significantly reduce the number by leveraging the assumption on the structure of K. Assume we know some blocks ({Kij}) of the matrix K are shared and in total there are h different kinds of blocks, which we denote as K̂ ∈ Rh×m×m. Then, the number of parameter to be identified reduce to hm2. Usually, h does not depend on N , and is much smaller than N2. Now, for each block Kij , we have a one-hot vector σij ∈ {0, 1}h indicating its type, i.e., Kij = σijK̂ ∈ Rm×m. Finally, as shown in equation 7, we represent the Koopman matrix as the product of the index tensor σ and the parameter tensor K̂:
K = σ ⊗ K̂ = σ11K̂ · · · σ1NK̂... . . . ... σN1K̂ · · · σNNK̂  ,where σ = σ11 · · · σ1N... . . . ... σN1 · · · σNN  ∈ RN×N×h. (7) Similar to the Koopman matrix, we assume the same block structure in the control matrix L and denote its parameter as L̂ ∈ Rh×m×l. The least squares problem of identifying K̂ and L̂ becomes
min K̂,L̂ ‖(σ ⊗ K̂)g1:T−1 + (σ ⊗ L̂)ũ− g2:T ‖2, (8)
where σ ⊗ K̂ ∈ RNm×Nm, σ ⊗ L̂ ∈ RNm×Nl, g1:T−1 ∈ RNm×(T−1) and ũ ∈ RNl×(T−1). Since the linear least squares problems described in equation 6 and equation 8 have analytical solutions, performing system identification using our method is very efficient.
Training GNN models. To make predictions on the states, we use a graph decoder ψ to map the Koopman embeddings back to the original state space. In total, we have three losses to train the graph encoder and decoder. The first term is the auto-encoding loss
Lae = 1
T T∑ i ‖ψ(φ(xi))− xi‖. (9)
The second term is the prediction loss. To calculate it, we rollout in the Koopman space and denote the embeddings as ĝ1 = g1, and ĝt+1 = Kĝt + Lut, for t = 1, · · · , T − 1. The prediction loss is defined as the difference between the decoded states and the actual states, i.e.,
Lpred = 1
T T∑ i=1 ‖ψ(ĝi)− xi‖. (10)
Third, we employ a metric loss to encourage the Koopman embeddings preserving the distance in the original state space. The loss is defined as the absolute error between the distances measured in the Koopman space and that in the original space, i.e.,
Lmetric = ∑ ij ∣∣‖gi − gj‖ − ‖xi − xj‖∣∣ . (11) Having Koopman embeddings that perserves the distance in the state space is important as we are using the distance in the Koopman space to define the cost function for downstream control tasks.
The final training loss is simply the combination of all the terms above: L = Lae+λ1Lpred+λ2Lmetric. We then minimize the loss L by optimizing the parameters in the graph encoder φ and graph decoder ψ using stochastic gradient descent. Once the model is trained, it can be used for system identification, future prediction, and control synthesis.

heading: 3.4 CONTROL
text: For a control task, the goal is to synthesize a sequence of control inputs u1:T that minimize C =∑T t=1 ct(x
t,ut), the total incurred cost, where ct(xt,ut) is the instantaneous cost. For example, considering the control task of reaching a desired state x∗ at time T , we can design the following instantaneous cost, ct(xt,ut) = 1[t=T ]‖xt − x∗‖22 + λ‖ut‖22. The first term promotes the control sequence that matches the state to the goal, while the second term regularizes the control signals.
Open-loop control via quadratic programming (QP). Our model maps the original nonlinear dynamics to a linear dynamical system. We can then solve the control task by solving a linear control problem. With the assumption that the Koopman embeddings preserve the distance measure, we define the control cost as ct(gt,ut) = 1[t=T ]‖gt − g∗‖22 + λ‖ut‖22. As a result, we reduce the problem to minimizing a quadratic cost function C = ∑T t=1 ct(g
t,ut) over variables {gt,ut}Tt=1 under linear constrains gt+1 = Kgt + Lut, where g1 = φ(x1) and g∗ = φ(x∗).
Model predictive control (MPC). Solving the QP gives us control signals, which might not be good enough for long-term control as the prediction error accumulates. We can combine it with Model Predictive Control, assuming feedback from the environment every τ steps.

heading: 4 EXPERIMENTS
text: Environments. We evaluate our method by assessing how well it can simulate and control ropes and soft robots. Specifically, we consider three environments. (1) Rope (Figure 2a): the top mass of a rope is fixed to a specific height. We apply force to the top mass to move it in a horizontal line. The rest of the masses are free to move according to internal force and gravity. (2) Soft (Figure 2b): we aim to control a soft robot that is consist of soft blocks. Blocks in dark grey are rigid and those in light blue are soft blocks. Each one of the dark blue blocks is soft but have an actuator inside that can contract or expand the block. One of the blocks is pinned to the ground, as shown using the red dots. (3) Swim (Figure 2c): instead of pinning the soft robot to the ground, we let the robot swim in fluids. The colors shown in this environment have the same meaning as in Soft.
Observation space. In the Rope environment, each mass on the rope is considered as an object. The observation of each mass is its position and velocity in the 2D plane, which has a dimension of 4. In total, a rope with N masses has an observation space of dimension 4N . In both the Soft and the Swim environments, each quadrilateral is considered as an object. For each quadrilateral, we have access to the positions and velocities of the four corners. Thus for a soft robot containing N quadrilaterals, we have a 4× 4×N = 16N dimensional observation.
Baselines. We compare our model to the following baselines: Interaction Networks (Battaglia et al., 2016) (IN), Propagation Networks (Li et al., 2019b) (PN) and Koopman method with handcrafted Koopman base functions (KPM). IN and PN are the state-of-the-art learning-based physical simulators, and we evaluate their adaptation ability by finetuning their parameters on a small sequence of observations from the testing environment. Similar to our method, KPM fits a linear dynamics in the Koopman space. Instead of learning Koopman observations from data, KPM uses polynomials of the original states as the basis functions. In our setting, we set the maximum order of the polynomials to be three to make the dimension of the hand-crafted Koopman embeddings match our model’s.
Data generation. We generate 10,000 episodes for Rope and 50,000 episodes for Soft and Swim. Among them, 90% are used for training, and the rest for testing. Each episode has 100 time steps. In the dataset, the physical systems have a various number of objects from 5 to 9, i.e. the ropes have 5 to 9 masses while the soft robots in Soft and Swim environments have 5 to 9 quadrilaterals. To evaluate the model’s extrapolating generalization ability, for each environment, we generate an extra dataset with the same size as the test set while containing systems consist of 10 to 14 objects.
Training and evaluation protocols. All models are trained using Adam optimizer (Kingma & Ba, 2015) with a learning rate of 10−4 and a batch size of 8. λ1 and λ2 are 1.0 and 0.3, respectively, for our model. For both our model and the baselines, we apply 400K iterations of gradient steps in the Rope environment and 580K iterations in the Soft and Swim environment. Our model is trained on the sub-sequence of length 64 from the training set, and IN/PN aims at minimizing the L1 distance between their prediction and the ground truth. During test time, the models have to adapt to a new environment of unknown physical parameters, where they have access to a short sequence of observations and the opportunity to adjust their models’ parameters. Our model uses 8 episodes to identify the transition matrix via least-square regression. IN/PN update the model’s parameters by minimizing the distance between the model’s prediction and the actual observation using a gradient step of length 10−4 for 5 iterations. For evaluation, we use two metrics: simulation error and control error. For a given episode, the simulation error at time step t is defined as the mean squared error between the model prediction x̂t and the ground truth xt. For control, we pick the initial frame x0 and the t’th frame xt from a episode. Then we ask the model to generate a control sequence of length t to transfer the system from the initial state x0 to the target state xt. The control error is defined as the mean squared distance between the target state and the state of the system at time t.

heading: 4.1 SIMULATION
text: Figure 2 shows qualitative results on simulation. Our model accurately predicts system dynamics for more than 100 steps. For Rope, the small prediction error comes from the slight delay of the force propagation inside the rope; hence, the tail of the rope usually has a larger error. For Soft, our model captures the interaction between the body parts and generates accurate prediction over the global movements of the robot. The error mainly comes from the misalignment of some local components.
We evaluate the models by predicting 100 steps into the future on 500 trajectories and Figure 3 shows quantitative results. IN and PN do not work well in the Rope and Swim environments due to insufficient system identification ability. The KPM baseline performs poorly in the Rope and
Soft environments indicating the limited power of polynomial Koopman base functions. Our model significantly outperforms all the baselines.

heading: 4.2 CONTROL
text: We compare our model with KPM, the Koopman baseline using polynomial basis. In Rope, we ask the models to perform open-loop control where it only solves the QP once at the beginning. The length of the control sequence is 40. When it comes to Soft/Swim, each model is asked to generate control signals of 64 steps, and we allow the model to receive feedback after 32 steps. Thus every model has a second chance to correct its control sequence by solving the QP again at the time step 32.
As shown in Figure 2, our model leverages the inertia of the rope and matches the target state accurately. As for controlling a soft body swinging on the ground or swimming in the water, our model can move each part (the boxes) of the body to the exact target position. The small control error comes from the slight misalignment of the orientation and the size of the body parts. Figure 4 shows that quantitatively our model outperforms KPM, too.

heading: 4.3 ABLATION STUDY
text: Structure of the Koopman matrix. We explore three different structures of the Koopman matrix, Block, Diag and None, to understand its effect on the learned dynamics. None assumes no structure in the Koopman matrix. Diag assumes a diagonal block structure of K: all off-diagonal blocks (Kij where i 6= j) are zeros and all diagonal blocks share the same values. Block predefines a block-wise structure, decided by the relation between the objects as introduced in Section 3.3.
Table 1 includes our model’s simulation error and control error with different Koopman matrix structures in Rope. All models are trained in the Rope environment with 5 to 9 masses. Besides the result on the test set, we also report models’ extrapolation performance in parentheses, where the model is evaluated on systems with more masses than training, i.e., 10 to 14 masses.
Our model with Block structure consistently achieves a smaller error in all settings. Diag assumes an overly simplified structure, leading to larger errors and failing to make reasonable controls. None has comparable simulation errors but larger control errors. Without the structure in the Koopman matrix, it overfits the data and makes the resulting linear dynamics less amiable to the control.
Hyperparameters. In our main experiments, we set the dimension of the Koopman embedding to m = 32 per object. Online system identification requires 800 data samples for each training/test case. To understand our model’s performance under different hyperparameters, we vary the dimension of the Koopman embedding from 8 to 64 and the number of data samples used for system identification from 200 to 1,600. Figure 4d shows that more data for system identification leads to better simulation results. Figure 4e shows that dimension 16 gives the best results on simulation. It may suggest that the intrinsic dimension of the Koopman invariant space of the Rope system is around 16 per object.

heading: 5 CONCLUSION
text: Compositionality is common in our daily life. Many ordinary objects contain repetitive subcomponents: ropes and soft robots, as shown in this paper, granular materials such as coffee beans and lego blocks, and deformable objects such as cloth and modeling clay. These objects are known to be very challenging for manipulation using traditional methods, while our formulation opens up a new direction by combining deep Koopman operators with graph neural networks. By leveraging the compositional structure in the Koopman operator via graph neural nets, our model can efficiently manipulate deformable objects such as ropes and soft robots, and generalize to systems with variable numbers of components. We hope this work could encourage more endeavors in modeling larger and more complex systems by integrating the power of the Koopman theory and the expressiveness of neural networks.

heading: A ENVIRONMENT AND MODEL DETAILS
text: Interaction types. In our experiments, interactions are considered different if the types are different or the objects involved have different physical properties.
In the Rope environment, the top mass has a fixed height and is considered differently from the other masses. Thus, we have 2 types of self-interactions for the top mass and the non-top masses. In addition, we have 8 types of interactions between different objects. The objects on a relation could be either top mass or non-top mass. It is a combination of 4. And the interaction may happen between two nearby masses or masses that are two-hop away. In total, the number of interactions between different objects is 4× 2 = 8. In the Soft environments, there are four types of quadrilaterals: rigid, soft, actuated, and fixed. We have four types of self-interactions correspondingly. For the interactions between objects, we add edges between two quadrilaterals only if they are connected by a point or edge. Connection from different directions are considered as different relations. There are 8 different directions, up, down, left, right, up-left, down-left, up-right, down-right. The relation types also encode the type of receiver object. Thus, in total, there are (8 + 1)× 4 = 36 types of relations between different objects. In the Swim environment, there are three types of quadrilaterals: rigid, soft, and actuated. Similar to the Soft environment, we use different edge types for different connecting directions; hence, the number of edge type is (8 + 1)× 3 = 27.

heading: B ADDITIONAL EXPERIMENTS
text: Comparison with a classical physical simulator optimized using back-box optimization. We have performed comparisons with a classical physical simulator optimized using black-box optimization (Delingette, 1998) by assuming different levels of knowledge over the ground truth model.
If we assume that we know the ground truth model, where we only need to identify relevant physical parameters during the system identification stage, Bayesian Optimization (Snoek et al., 2012) (BO) can give us a reasonable estimate of the physical parameters. However, BO requires much more time to achieve a comparable performance with our method in the Rope environment: 0.43 vs. 180 seconds averaged over 100 trails (Ours vs. BO).
If we are unsure about the ground truth model and we approximate the system using a set of points linked by springs and dampers, BO does not work as well. In our additional experiments, we approximate the Rope environment using a chained spring-mass system, say n masses and n − 1 springs. While taking much more time, BO still cannot give us a satisfying result: simulation error 0.046 vs. 0.084 and control error 0.854 vs. 2.547 (Ours vs. BO).
Ablation study on the effectiveness of the metric loss. The internal linear structure allows us to solve the control problem using quadratic programming, where the objective function for control is defined in the embedding space (Section 3.4); hence, it is desirable to have Koopman embeddings that preserve the distance in the original state space. In Section 3.3, we introduce a metric loss to promote learning a Koopman embedding that keeps the distance measurement.
To demonstrate the effect of the metric loss, we compare the models trained with and without the metric loss. We establish the comparison using two measurements, the distance preservation and the prediction accuracy. To evaluate how well the Koopman embeddings preserve the distance, we compute the distribution of the log-ratio of the distance in the Koopman space and in the original state space, i.e., log ( ‖gi−gj‖2 ‖xi−xj‖2 ) . For the model prediction accuracy, we show the simulation errors.
We perform the experiments in the Rope environment and show the result in Figure 5. On the left, we show the ratio of distance in the learned Koopman space and the distance in the original state space. The model trained with metric loss has a log distance ratio that significantly more concentrates on 0. It means the metric loss effectively regularizes the model to preserve the distance. On the right, we show the simulation errors of the two models, which indicate that two models have comparable prediction performance. Metric loss effectively enhances the property of distance-preserving while not making a big sacrifice on the accuracy of the dynamics modeling.
(a) Distance Preservation (b) Simulation
Pr ob
ab ili
ty D
en si
ty
°1.5 °1.0 °0.5 0.0 0.5 1.0 1.5 0
2
4
6
8 w/ metric loss
w/o metric loss
M ea
n Sq
ua re
d Er
ro r
w/ w/o 0
1
2
3
4
w/ metric loss w/o metric loss
M ea
n Sq
ua re
d Er
ro r
(c) Control 0 20 40 60 80 100
0.0
0.1
0.2
0.3 w/ metric loss
w/o metric loss
Figure 5: Ablation study on the metric loss in the Rope environment. (a) shows the distributions
of the logarithm distance ratio, i.e, log
(
‖gi−gj‖2 ‖xi−xj‖2
)
. The model trained with metric loss has a distance ratio much more concentrated to 1, which indicates it preserves the distance much better than the counterpart. (b) illustrates the simulation error of two models, where their performance is on par. (c) shows that the model trained using the metric loss performs better control.
Experiments in a known physical parameter setting. Our setting is different from the settings in the original IN and PN papers that we do not assume we know the physical parameters and their values, such as stiffness, mass, and gravity. Instead, the parameters are embedded in the transition matrices during the system identification stage (Section 3.3). If the model has access to the underlying physical parameters, as expected, IN and PN slightly outperform our method as the internal linear structure limits our model’s expressiveness, as shown in Figure 6. In the real world, however, the underlying physical parameters are not always known, which makes our model a better choice when adapting to unseen environments.

Review summaries:
The paper proposes a novel method for modelling dynamical systems over graphs. The main idea investigated by the authors is to combine Graph Neural Networks together with approximate Koopman embedding. The GNN encodes the input graph to what the authors call "object-centric embedding", whose concatenation over all objects is defacto the approximate Koopman embedding of the system.