Venue: NeurIPS 2021 Conference

Reviews:

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: The authors consider the problem of speeding up a specific form of dynamic simulation - position based dynamics, used as a solver to simulate the dynamic evolution of rods. I believe this is a timely topic, both due to the growing importance of simulations in various communities within AI, and because flexible objects are becoming more relevant in some of these applications.

The core concern of this paper is to find ways to speed up PBD solvers. To the extent that the iterative process of constraint projection is computationally expensive, there is scope for finding surrogates that could perform something like this computation quicker. The author's proposal is to use a Graph Neural Network to act as a surrogate for the analytical calculation. In contract to some other works that aim at replacing the entire simulator, the authors restrict the scope here to only using the neural network to emulating the specific projection step, which then serves as an initialisation, speeding up subsequent computation. This is a good idea and the empirical data supports its use. The empirical experiments in this paper are simulations of free evolution of a rod and a spring, clamped on one side, after an initial perturbation. It is shown that the proposed method can be more computationally efficient than an alternative which only uses the full conjugate gradient optimization step from a zero initialization.
main_review: I find the work to be sound, and well motivated. There is a need for efficient solvers, and there is also a need for methods that can provide long-term stability, which motivates modifying rather than replacing existing solvers. 

The proposed approach - to train a network to emulate the optimization step is a good one. However, as already queried by the reviewers of the previous submission, it is certainly interesting to consider what sort of surrogate is needed and how the resulting method behaves. The authors present a comparison against nearest neighbours, which is a natural baseline. The authors show that while this gives a small boost, the neural network does indeed perform better. Also, the authors note that the network alone would not be a good replacement as it performs very poorly outside the training data regime (which is in accordance with findings in other literature too).

All this raises the question of what can be said about the convergence and error characteristics of such a mixed method, beyond the empirical experiment. To the extent that this is a standard solver with established analysis methods, could one say more about the conditions for long term stability and could that constrain the neural network? Here I have in mind analogies to other numerical methods for speedups of solvers (e.g., the Parareal scheme for time-parallel speedup: https://en.wikipedia.org/wiki/Parareal, which comes with some conditions for stability). 

One reason to ask this question is that I am particularly interested in the behaviour of the network when the dynamics become stiff or otherwise numerically difficult. It is not entirely easy to tell from visual inspection of the variations in the scenarios how the ranges of Young's Modulus and rod lengths map to stiffness and longer time scale dynamic evolution - this is where I'd expect the neural network error characteristics to be less favourable. The current implementation requires normalisation of Young's modulus and torsion modulues in order to stabilise the algorithm. I am curious how all this behaves if the system under consideration were such that the underlying dynamics had slow-fast characteristics (perhaps because of inhomogeneous materials like composites or other phenomena like flutter). The paper would be made stronger by including some discussion of these kinds of issues.

Note added post-response:
I thank the authors for their response. I would encourage them to provide the additional information they have offered. Based on the discussion so far (including other reviews and the responses), I maintain my score.

limitations_and_societal_impact: The authors explicitly discuss limitations, and their arguments are on point. Ultimately, this is a methodological contribution to solver technology for dynamic simulation, and the limitations pertain to the balance between simulation and learning.

I do not believe this work raises societal issues that need to be considered specifically.
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: This paper aims to accelerate the iterative physical simulators using graph neural networks, by combining the traditional iterative rod solver and the graph networks. Instead of an end-to-end way, this paper uses the trained GNN to provide the initial guess of the iterative solver to reduce the number of iterations. In the experiments section, this paper shows the improved run time performance compared with the traditional solver and a KKN method. 
main_review: #### Strengths
- This paper uses the network output as the initial guess and then performs the iterative solver to correct the position, which is different from other data-driven simulators and the iterative solver can provide better long-term stability compared with the end-to-end methods.
- Compared with the traditional simulation methods, COPINGNet reduces the number of iterations by providing a better initial guess using GNNs which accelerate the simulation.
- This paper gives detailed steps about how to build the graph. And the supplementary video is illustrative.  

#### Weaknesses
- To use this method, all the works of a traditional PBD simulator cannot be avoided, and all the physics properties of the physical systems need to be known. 

#### Correctness  
The technical content of this paper appears to be correct.

#### Clarity  
Overall, the exposition of the paper is fairly clear. 

#### Relation to prior art  
This paper properly discusses the previous work of data-driven physics simulators and graph-based learning.  
This work can be seen as a combination of the traditional rod simulator and the GNN-based simulator.  
Compared with other GNN simulators, the main difference is that COPINGNet uses the output of GNNs as the initial guess for the iterative solver instead of an end-to-end way. Also, different from many other data-driven methods where the physical system is unknown, this paper assumes all the physics constraints are known to the iterative simulator. And many other GNN-based methods use particles as the graph nodes, while this model uses segments.   
Compared with other traditional solvers, this work uses a neural network to provide an initial guess for the solver.

#### Reproducibility  
Implementation details and code are provided in the supplementary materials to reproduce this work.

#### Additional Feedback/Questions
- Figure 4 compares COPINGNet’s inference time and the vanilla CG solver’s run time. Is the CG solver also implemented on GPUs? it would be clearer if the devices used to run the COPINGNet and the CG solver are listed since the run-time improvement may also come from the device or implementation difference.
- Is COPINGNet also used for generating the initial guess of the collisionConstraintProjection (line 13 in algo 1)?
- There are other methods that can learn end-to-end simulations using graph networks, is the difference here that the rods simulated in this work are too complicated to get a long-term stable prediction if without using the traditional projection solver to correct the results?
- It might be clearer if the formula of using λ to update p is given in algo 1.
- After training, can the model be used for different time steps or for systems with different physical attributes (e.g., rods with different stiffness)?

limitations_and_societal_impact: The paper properly discusses the limitations that COPINGNet is currently limited to rod simulation using position-based dynamics and mentions the possible future work of applying this method to other iterative methods.
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: This paper presents a learning-based technique to speed up the physics simulation of rod structures using PBD. The key motivation is to notice that solving the nonlinear system using CG is the key bottleneck in the physics simulation. To speed up the CG solver, this paper proposes to train a neural network that predicts a good initial guess for CG in the hope that it will reduce the number of iterations before convergence. This paper presents experiments with tens to over a thousand nodes and shows that the speedup technique reduces the number of iterations used in CG by a factor of at most 2.5 (Fig. 6).
main_review: Overall, this paper makes an attempt to combine learning-based approaches with classical physics simulation. In particular, the paper intentionally avoids training an end-to-end network that fully replaces simulation in a single time step. Instead, it bases its designs on a good understanding/decomposition of the underlying physics simulation technique (PBD) and chooses to train a network that proposes initial guesses to the numerical solver only. The implication is that their method naturally inherits the physical accuracy and stability of PBD because their method technically should lead to almost the same numerical results as the original PBD method. This gives their learning-based model some transparency and good guarantees on its physical correctness compared to an end-to-end network. I like this way of combining a network with a physics engine, and I think the authors should be given credits for this.

My scores cannot be higher for the submission in its current status because I still have some concerns regarding the technical methods and the experiments:

- To me, the improvement from their method over a classic CG seems not significant, and the speedup seems diminished especially when the problem scales up: for the first two examples mentioned in Fig. 4 and Fig. 6, the speedup seems to be between 1 and 3, and for the larger tree example, the speedup is reduced to less than 20%. Is there a reason why the performance degrades when the problem scales up? Even for the complex scene, the matrix size (a few thousand by a few thousand if I understand correctly) is not super large for a modern CG solver, so I wonder if the authors could provide the wall-clock time for simulating one time step for both the small and large examples. If these examples can already be simulated very fast (say in real time), then it might be hard to justify why it is still worth spending tens of hours of training to gain this relatively small speedup.

- Following the comment above, I notice the comparison is against a vanilla CG, which I find quite uncommon in modern physics simulators. Typically, modern simulators will at least equip CG with a preconditioner, which can speed up the vanilla CG at least a few times faster (this is also why I mentioned above that the speedup reported in this paper is not very impressive to me) especially for large-scale systems. There are also more advanced techniques like multigrid solvers that can expedite the vanilla solver even further. All these classical numerical methods do not require extra training time, making it difficult for me to appreciate the speedup obtained in this paper. On a side note, I would be much more excited if this paper proposes to learn a proper preconditioner instead of learning an initial guess to CG because a good preconditioner almost always ensures a decreased number of iterations in CG regardless of the initial guesses.

- I think the discussion of the generalizability of their neural network is very crucial to their method (or any methods trying to combine neural networks with physics engines in general) and I wish it could be elaborated in the main paper. In particular, 1) do I need to retrain the network if I switch to a different example with different topologies (e.g., from rods to trees)? The answer seems to be no from what I understand, but it would be good if the authors can confirm. 2) for the same example, if I change the external forces (e.g., removing gravity or adding wind forces in the tree example) or change to a different boundary condition (e.g., stitching an end of a rod to a wall or ground), do I need to retrain the network or does it still generalize well? 3) if I change the time steps used in physics simulation, do I need to retrain the network or does it still generalize well? 4) is the network described in Fig. 3 agnostic to rigid modes applied to the input? In other words, if I rotate and translate the whole rod system and send it to the network again, would I expect some change in its output?

limitations_and_societal_impact: See the review above.
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: This paper proposes to train a graph network to estimate the initial guess of a conjugate gradient solver in a rod dynamics simulation pipeline. By using a better initial position given by the graph network, the CG solver can converge faster than optimizing from zero vectors. The authors show how to construct such a network and demonstrate the accuracy and efficiency of their hybrid method in various simulation settings.
main_review: Originality: 
Yes. This is my first timing reading accelerating the simulation of rod dynamics using graph networks. I remember there are some previous works using graph networks to learn dynamics or using networks to accelerate fluid dynamics. The authors properly cite related works in Section 2.

Quality: 
The method looks reasonable to me and the rendering looks good. Just some small suggestions,
1. In the video around 1:30, there are unnatural oscillations. Maybe the collision handling is not perfect.
2. It might be more convenient for readers if some labels can be added to the plots (Fig. 4, 6).
3. It would be better to show the standard deviation in the plot.

Clarity:
Yes.

Significance:
This might be my main concern about this paper. 

First, the examples are relatively simple. The topologies are either linear or tree-like. Since graph networks are used, it will be more convincing if the method can simulate more complex graphs, like 2D or 3D nets. I’m also wondering what real-world application can be for this method.

Second, the performance boost is good but not so significant. If I understand the submitted code correctly, the CG solver is implemented using pytorch cuda tensor at an element-wise level. A C++ simulator might be orders of magnitude faster. If the simulator is implemented using C++, I doubt the performance gain of reducing several iterations in CG solver on the cost of running a graph network.

*** After authors’ response

The response points out that the acceleration could be more significant in larger-scale applications, which is good for generalization. The idea itself, using GNN to accelerate the solvers in physics problems, is interesting. I’m glad that the authors provide their code. It is understandable to use python implementation as a proof of concept. More efficient C++ implementation could be future work.

limitations_and_societal_impact: I don’t think there would be serious negative societal impacts in this work. The limitation of this work I think is its significance and real-world use, which I covered in the last part.
review_title: null

Meta-review: This paper considers accelerating the simulation of rod dynamics by training a graph neural network to act as an initialisation for an iterative solver. This is an interesting and original paper.
While reviewers were generally in favour of this paper, they had a number of concerns. The primary question, including after the rebuttal, is around the significance of the results. Despite that, there is value in this contribution.
The authors should make the promised changes to the manuscript.
Decision: Accept (Poster)