Venue: NeurIPS 2021 Conference

Reviews:

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: The paper proposes a method (LSH-SMILE) that applies LSH to speed up PDE forward simulation and backward learning.
Observing that most of the elements are very similar, they can be hashed into buckets and each bucket can be represented by a single value, thus reducing computational and memory cost. 
The method is validated empirically on two problems, grain growth and nanovoid simulation, showing that it is much faster than standard brute-force computation while maintaining reasonable accuracy.
main_review: Strengths:
- The paper is well-written and easy to understand. Section 3 provides valuable intuition, and I enjoyed reading it.
- The method works for both forward simulation and backward learning, by leveraging the nature of differential equations (instead of relying on auto-differentiation, which can be memory-costly).
- The method can significantly speed up the PDE simulation and learning.

Weaknesses:
1. Limitation of application: it's not clear to me how widely the proposed method can be apply, as there's no discussion of its limitations. It seems to work for two narrow physics problem. However, I'm not sure which conditions will allow it to work well. This is the most significant weakness.
2. It seems that the algorithm is hard to parallelize, compared to the brute-force simulation. Thus the brute-force computation may able to better use GPUs to speed it, while LSH-SMILE would be bound to CPUs?

Questions:
1. The observation that close-by elements are very similar, is quite reminiscent of fast multi-pole method. I wonder if there's a connection here.
2. In Figure 3, Func OneStep, line 15, the ActiveL set is updated when the change is larger than r. However, what if the change per iteration is smaller than r but over time it can add up to be larger than r. Would the ActiveL set be updated then?

============== Post-rebuttal

Thank you for the response to my questions. That has helped me understand the method better. 

The clarification on the setting where the method is expected to work is valuable. Given that the goal of the paper is to accelerated simulation and learning on physical systems in general, I think the case could be made much stronger if the applications are more diverse.

I've increased my rating.
limitations_and_societal_impact: Yes
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: In learned Partial Differential Equation (PDE) solvers, the forward simulation (thereby data collection) and backward learning processes are very time consuming. This paper tries to mitigate this issue by using Locality Sensitive Hashing (LSH). 

The motivation for this approach comes from three critical observations - 
1) that most PDE updates in a close vicinity tend to be similar ,i.e., in a one step update, most elements change only on few steps and remain unchanged in the rest of the process.
2) one step updates for a element is dependent on the neighborhood (neighborhood can be thought of a context in NLP).
3) most points share similar temporal dynamics

In learned PDE, the practical simulation happens by discretizing finite-difference approach and obtaining learnable vectors.

Starting from an initial state and hashing to one bucket per element, LSH-Smile iteratively pools elements that have similar hash codes into the same buckets. On each hash bucket, there will be a classic PDE update (same update for all elements in a bucket). Then the hash codes of buckets are updated to  obtain the ones with significant change (>r, a threshold). Then the elements in those buckets are rehashed.

The backward process is similar with an additional gradient computation step that I presume is also done a bucket basis.

I’m not entirely sure abt the input structure and the hash function used (I may have missed some details).

But essentially, LSH-SMILE does the standard updates process on a chunk by chunk basis instead of on all elements.





main_review: Strengths

1. Neat idea
2. Impressive gains in time and memory with negligible difference with ground truth simulations.
limitations_and_societal_impact: Limitations:

1. LSH theory is a direct import from prior literature (understandable though). The primary novelty is integrating it with the PDE solver's forward and backward passes. 

2. There maybe PDE applications where the three critical observations might not hold.

3. Noticeable typos like

line 183 : perform update ---> perform an update
line 189 : every elements --> every element 
line 257 : by we directly coding --> because we directly coded
line 258 : rules is --> rules are
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: This paper proposes a novel LSH based approach for efficient forward and backward pass of Partial Differential Equations (PDEs). The proposed LSH-SMILE approach focus on local updates and use LSH to find the local neighbors. Moreover, LSH-SMILE propose a bucket merging method to avoid empty buckets.
main_review: Strength:
1. Novel formulation that transforms PDEs into the nearest neighbor problem
2. Efficient combination of LSH and PDEs.
3. Error bounds for the errors
limitations_and_societal_impact: Suggestions:

LSH is a great approach for scaling up large scale machine learning models. Is is possible to demonstrate more experiments on larger scale?
review_title: null

final_score: rating: 6: Marginally above the acceptance threshold
review_content: summary: The paper applies locality sensitive hashing to neural networks for solving Partial Differential Equations (PDEs). The paper proposes a solution called LSH-SMILE and claims several contributions: (1) LSH-SMILE achieves a drastic improvement in scalability than conventional approaches. (2) Theoretically, the paper proves a novel bound on the errors introduced by LSH-SMILE (3) Experimentally, the paper demonstrates LSH-SMILE exhibits comparable quality with exact approaches but costs less time and space.  
main_review: The paper is novel that applies Locality Sensitive Hashing (LSH) to physics systems for faster runtime. As a tradeoff, LSH introduces errors to the physic systems since LSH is an approximate approach. But the paper demonstrates that the errors are acceptable since the simulation quality of the physics system can match the quality of using conventional exact match approach, as shown in Figure 4 and Figure 5. Runtime-wise, the proposed method LSH-SMILE can outperform conventional approach by more than 10 times, as shown in Table 1.  

Although the paper has merits in integrating computer science approaches with physics systems, it contains a lot of undefined physical terms that affect the understanding of the paper for general computer science audiences (like myself). The undefined physical terms impact reproducibility of the experiments as well. In particular, I suggest the authors improve the draft as follows:

(1)	Provide definitions for technical terms before using them, in plain language that general audiences can understand. For example, “forward simulation” and “backward learning” are introduced early in the Abstract, but they are not standard terms in computer science. Although computer science researchers often use “forward propagation” and “backward propagation” in neural networks, it is not sure whether the authors refer to the same things. There are a lot of undefined technical terms in the paper, such as “Partial Differential Equations”, “elements”, and “temporal dynamics” in the Abstract. 

(2)	Provide toy examples for long definitions. The paper gives a definition for Partial Differential Equation (PDE) in Section 2 Preliminaries. The definition is as long as half a page, but the paper does not give any toy examples. It is unclear what a PDE looks like. 

(3)	Specify the inputs and outputs of the LSH algorithm. The input format of an LSH algorithm should be a query vector and a set of item vectors. The output format should be the most similar item vectors to the query vector. When applying LSH to physics systems, it is natural that one has to formulate physics systems into query vector and item vectors. However, the paper does not illustrate how the formulation looks like. It will be good if the authors can add the details to the paper for better clarity.

limitations_and_societal_impact: There is no sign of negative impact.
review_title: null

Meta-review: All the reviewers concurred that this paper is above bar for publication. Rebuttal reaffirmed that sentiment. Reviewers like the idea of using LSH for speeding up simulations.  In particular,  applying LSH algorithm to a completely new domain, i.e. physic systems. The results look promising and since the paper belongs to interdisciplinary research, reviewers agree that even though the paper is less advanced in algorithmic techniques, it will be a educative read for a broader community of people. 

Please take in account comments from the reviewers to improve the paper.   
Decision: Accept (Poster)