acceptodds
Under review as a conference paper at ICLR 2027

Function-Space Transformer with Adaptive Anchors

Abstract

Many forms of data, including physical fields, geometric shapes, and visual signals, are naturally described by functions over continuous domains but are observed through discrete samples. Representing these functions on fixed uniform grids imposes a trade-off between resolving localized variation and increasing computation across the domain. Neural operators address this mismatch by learning mappings between functions, while latent-attention architectures provide flexible processing of sampled observations. We introduce the Function-Space Transformer (FST), a framework for learning from functions through a spatially adaptive continuous latent representation. FST stores features at anchors whose locations are predicted from the input observations and recursively refines these anchor features through function-space interactions. This allows the representation to adapt its spatial organization to each input rather than inherit that of the observation grid, while supporting both spatially resolved and finite-dimensional outputs. On PDE solution prediction using PDEBench Burgers and Darcy flow, FST substantially outperforms the Perceiver IO baseline, whose latent representation lacks explicit spatial organization, and is highly competitive with the Fourier Neural Operator. On ImageNet-1K, FST achieves higher classification accuracy than the Vision Transformer baseline, with fewer parameters across these comparisons. Ablations further support the benefits of function-space updates and recursive refinement. Together, these results highlight the potential of adaptive continuous representations for both scientific prediction and visual recognition.

Primary area:
unsupervised, self-supervised, semi-supervised, and supervised representation learning
Keywords:
Transformers, Neural Fields, Operator Learning, Geometric Deep Learning

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_7QQgOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes an adaptive spatial latent representation with a reasonable architectural design. Its main idea is to separate latent feature storage from attention computation. The experiments show promising results on a few tasks. However, there is still not enough evidence that the method outperforms existing neural operators in accuracy or efficiency. Its generalization across different discretizations also remains unclear.

Critical strengths

The main strength of FST is its architectural design. It separates where latent features are stored from where global attention is performed. This gives the model more flexibility in how it represents and processes spatial information. Another interesting aspect is that the anchor positions can adapt to each input instead of staying fixed. I think combining these two ideas is a reasonable way to build a more flexible spatial representation. The overall design makes sense, even though its practical advantages still need stronger experimental evidence.

Critical weaknesses

My main concern is that the experiments do not provide enough evidence to justify the additional complexity of the proposed architecture. Most comparisons focus on prediction accuracy and parameter count. The paper reports some training time and GPU memory usage, but there is no systematic comparison of FLOPs, inference speed, or scalability. FST introduces several extra components, including anchor prediction, RBF interpolation, and recursive attention. All of these come with additional computational costs. Without a fair comparison under similar computational budgets, it is hard to tell whether these components are actually worth the added complexity. It would also be useful to see how the computational cost changes as the number of anchors, evaluation points, and input observations increases.

Another important issue is that the experiments do not clearly show why the proposed architecture is better than simpler spatial latent Transformers. The current ablations show some improvements, but they change multiple things at once. For example, replacing the function-space interaction with direct anchor self-attention also changes the number of tokens and the overall computation. This makes it difficult to identify where the improvements really come from. The benefits of adaptive anchors are also not consistent across different settings. More comparisons with recent spatial latent architectures would help. In particular, I would like to see whether adaptive anchors and function-space interactions still provide meaningful improvements when the models have comparable FLOPs, memory usage, and training budgets.

Questions for authors
  1. Does the additional architectural complexity actually lead to better accuracy-efficiency trade-offs than recent neural operators, under a fair computational budget?

  2. Does the model learn a physically meaningful spatial representation, or does it simply benefit from additional flexibility in latent parameterization?

3 comments

Thank you for the thorough review.

Summary

Its generalization across different discretizations also remains unclear.

For outputs, a single trained FST keeps an error near 0.046 on every output grid from 32 × 32 to 201 × 1024, while Transolver's error rises from 0.061 to 0.136 on the coarsest grid (Table 3). For inputs, the newly added Table 20 tests trained FST on input subsets without retraining. With every fourth Burgers input value, FST's error is nearly unchanged. With a 64 × 64 Darcy input, FST's error increases by 5%. Randomly chosen subsets are harder, because FST saw only evenly spaced inputs during training. For random subsets, users should first interpolate the inputs to the training points.

Weaknesses

there is no systematic comparison of FLOPs, inference speed, or scalability [...]

We agree. The revision adds a cost study in Appendix E. Table 27 reports FLOPs, inference time and memory for every Burgers and Darcy model. Figure 13 shows how FST's cost changes with the number of anchors, evaluation points, inputs and queries. Figure 14 compares model accuracy at equal training cost. Above a fixed base, FST's FLOPs grow linearly with inputs, queries and evaluation points. Predicting anchor coordinates accounts for only 1-3% of the FLOPs. Our answer to your first question below summarizes the findings.

The current ablations show some improvements, but they change multiple things at once.

We agree. Replacing the function-space update with self-attention over the anchors also changes the token count and removes the write-back. We therefore added a matched variant that changes only the field evaluation. Instead of evaluating the latent field at 512 points, the variant uses 512 learned tokens that read the anchors by cross-attention, like inducing points in Set Transformer. The rest of the update, token count and training protocol stay the same. The variant has 3.5% more parameters and about 3% fewer FLOPs. Evaluating the field lowers the error by 28% (0.0441 vs. 0.0614 over five seeds, Table 5).

The benefits of adaptive anchors are also not consistent across different settings.

We agree, and three seeds now show when adaptive anchors help. Adaptive anchors help with few anchors and when FST adapts length scales alongside coordinates. With 16 × 16 anchors, the fully adaptive design gives the lowest error (0.0486 vs. 0.0511 for the best uniform layout). With 32 × 32 anchors, a uniform layout is about as accurate as adaptive anchors. Section 4.2 now states these conditions instead of a general benefit.

More comparisons with recent spatial latent architectures would help.

We added the Universal Physics Transformer (UPT, NeurIPS 2024) as a baseline on Burgers and Darcy. We trained UPT under the protocol of the other baselines, with the same parameter budget and three seeds. FST has the lower mean error on both problems: 0.0461 vs. 0.0538 on Burgers and 0.0270 vs. 0.0334 on Darcy (Tables 3 and 7).

Questions

Does the additional architectural complexity actually lead to better accuracy-efficiency trade-offs than recent neural operators [...]?

Compared with Transolver, yes. At equal training cost, FST has lower error than Transolver throughout training on Burgers, and after about the first two GPU-hours on Darcy. At inference FST runs more than ten times faster than Transolver on the full Burgers grid at batch size 1.

Compared with FNO, the answer depends on the setting. On Burgers, FST reads only 1,424 input values and trains on 2,500 sampled output points, so each update is cheap. FST reaches lower error than FNO for training budgets between roughly one and four GPU-hours and uses about a fifth of FNO's memory. With longer training, FNO becomes more accurate. On Darcy, every grid value is an input, so FST needs far more FLOPs and memory than FNO, though FST ends up more accurate (0.0270 vs. 0.0326 over three seeds). So FST gives the better trade-off for sparse inputs with predictions at selected points, and FNO gives the better trade-off on dense regular grids. At test time, localized queries can also decode from 16 nearby anchors on Burgers with little loss in accuracy (Section 4.4). The new limitations paragraph in Section 5 states this trade-off.

Does the model learn a physically meaningful spatial representation, or does it simply benefit from additional flexibility [...]?

Input adaptation and extra flexibility both play a role. The learned layouts clearly depend on the input. On ImageNet the anchors gather on the object (Figure 12), and on Darcy the anchors shift from one input to the next (Figure 10). The extra flexibility also helps with few anchors, as in the 16 × 16 result above.

Thank you for the detailed response and the additional experiments. The new results address many of my concerns about computational efficiency and experimental fairness. They make the paper more convincing from an experimental perspective. However, my main concerns about architectural novelty and scientific understanding remain largely unchanged.

My biggest concern now comes from the new results on adaptive anchors. With 256 anchors, the fully adaptive design reduces the error by about 4.9% compared to the best uniform layout. With 1,024 anchors, the uniform layout performs about as well as the adaptive one. This suggests that the benefits of adaptive anchors are limited to certain settings. If adaptive anchors are not a major source of the performance improvement, it is unclear why they are presented as a central contribution and even highlighted in the title.

I also remain concerned about generalization across different discretizations. The authors suggest interpolating randomly sampled inputs back to the training points. This indicates that the trained model is still dependent on the input discretization used during training. Being able to accept arbitrary input coordinates does not necessarily mean that the model generalizes well across different discretizations.

Overall, I appreciate the effort the authors have made to improve the experimental evaluation. However, the new results do not substantially strengthen the architectural novelty or provide a deeper understanding of why the proposed design is better than existing alternatives. Comparisons with the most closely related spatial latent architectures are still limited, and the necessity of adaptive anchors remains unclear. For these reasons, I would keep my original rating.

Thank you for reading it closely.

Uniform placement can be seen as a special case of adaptive anchors. Adaptive anchors show a clearer improvement when anchors are scarce and length scales adapt as well (Section 4.2). In practice, we use adaptive anchors by default.

On input discretization, our earlier remark "For random subsets, users should first interpolate the inputs to the training points" was stated too broadly. Interpolation was only a suggestion when testing models that are not specifically trained on random subsets. Table 20's Direct column shows the performance on different discretizations at the inference stage (without retraining), while the Interpolated column shows the performance when interpolating back to the original input grid to keep the number of input points fixed. Direct FST stays robust across different discretizations without interpolation: its error is nearly unchanged from 1,424 down to 356 Burgers inputs (0.0461 to 0.0464, whereas Transolver rises from 0.0607 to 0.2677).

Interpolation only helps the test on Burgers when the input points are randomly chosen, because all models were only trained on evenly spaced 1D inputs. When testing with random subsets, UPT and Transolver show the same performance drop without interpolation, while FST actually keeps the lowest error. Below is the comparison with UPT and Transolver.

Burgers inputPointsFST (Direct / Interpolation)UPT (Direct / Interpolation)Transolver (Direct / Interpolation)
Training inputs1,4240.0461 ± 0.0062 / -0.0538 ± 0.0068 / -0.0607 ± 0.0005 / -
Every 2nd value7120.0462 ± 0.0062 / 0.0460 ± 0.00620.0538 ± 0.0069 / 0.0538 ± 0.00680.1460 ± 0.0403 / 0.0607 ± 0.0006
Every 4th value3560.0464 ± 0.0065 / 0.0471 ± 0.00610.0545 ± 0.0069 / 0.0543 ± 0.00660.2677 ± 0.0453 / 0.0615 ± 0.0011
Every 8th value1780.0550 ± 0.0052 / 0.0573 ± 0.00460.0570 ± 0.0069 / 0.0561 ± 0.00640.4017 ± 0.0532 / 0.0668 ± 0.0018
Random half7120.0766 ± 0.0053 / 0.0467 ± 0.00590.0871 ± 0.0064 / 0.0538 ± 0.00690.1577 ± 0.0328 / 0.0610 ± 0.0006
Random quarter3560.1036 ± 0.0046 / 0.0502 ± 0.00610.1085 ± 0.0100 / 0.0547 ± 0.00730.2792 ± 0.0557 / 0.0626 ± 0.0016

Thank you again for the constructive discussion.

Reviewer_yqDDOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper proposed an attention based architecture to model function inputs - inputs that are samples from a continuous function. The key idea is to first predict a list of anchor points which will be used to store latent features. The latent features are then used to interact with the spatial features. Since the heavy compute is restricted to a fixed set of latent features, the compute is tractable even with many samples. The paper compared this designed with other neural operators in two PDE setting and with ViT on ImageNet classification.

Critical strengths

The problem is interesting and important to study. The proposed method has the potential since the heavy compute is bounded by the anchor points, which is also adaptive since it's learned and updated.

Critical weaknesses
  • The paper missing references such as one of the closest related work is Functional Attention [A], which also tries to reformulate attention in function space. It is important to include and compare.
  • Novelty is an issue. It's not clear to me what is the novelty in terms of network architecture design comparing to other transformer and or perceiver based architectures, where cross-attention plays an essential role to kept the arbitrarily sampled tokens into a fixed set of latents (one can call it anchors or whatever). The notation makes all of these look fancy and new, but it's very difficult to decipher what is actually the new technique and what kind of technical gap does the proposed method can uniquely solve.
  • Experiment validation is also very weak. For the Darcy Flow table, it's not clear to me why reported error differ significantly from those reported by the original paper. For example, Transolver is able to report better performance comparing to FNO methods while Table 7 reports opposite results. What is the difference in the experiment set-up that leads to this? How do we explain the number of supervision points surpassing the total number of points in Table 1? Is there any results on more difficult PDEs like Navier-stokes?

[A] Xiao, Jiefang, et al. "Functional Attention: From Pairwise Affinities to Functional Correspondences." ICML 2026.

Questions for authors

See previous sections.

1 comment

Thank you for the review.Thank you for the review.

Weaknesses

one of the closest related work is Functional Attention [A] [...] It is important to include and compare.

Thank you for pointing us to Functional Attention. We now cite and discuss Functional Attention in Section 2. Both works bring attention into function space, but each method changes a different part. Functional Attention replaces the softmax attention weights with structured linear maps between adaptive bases. FST keeps ordinary softmax attention and changes the input of attention. FST applies attention to values of a continuous latent field and writes the mixed values back to the anchors.

Novelty is an issue. [...] what is actually the new technique and what kind of technical gap does the proposed method can uniquely solve.

You are right that compressing arbitrary samples into a fixed set of latents by cross-attention is a known step. FST adopts that step from Perceiver, as Section 3.1 states. The new parts are what the latents represent and how FST updates the latents.

First, the latents form a continuous field. In Perceiver, the latents are an unordered array without positions. FST predicts a coordinate from the input for each latent, called an anchor. Together, the anchors define a continuous field over the whole domain through RBF interpolation. Because every anchor has a position, FST can decode a query from the nearby anchors. On Burgers, the 16 nearest of 1,024 anchors nearly match full decoding in Section 4.4. With the same number of parameters, FST's error is about a quarter of Perceiver IO's on Burgers, 0.018 vs. 0.073, and about a fifth on Darcy, 0.027 vs. 0.127.

Second, FST applies attention to the field, not to the latents. Each step evaluates the field at sampled points, applies self-attention to the sampled values, and writes the mixed values back to the anchors. In a new ablation, we replace only the field evaluation with learned tokens that read the anchors by cross-attention. Both variants use the same token count and nearly identical parameters and FLOPs. Evaluating the field gives a 28% lower error (0.0441 vs. 0.0614 over five seeds, Table 5).

Third, FST refines the field recursively. FST applies one shared layer four times, and each pass adds a correction to the field. With the same number of parameters, four passes give a 34% lower error than one pass (Table 6).

We also agree that the notation made standard components look new. Equations 2 and 4 are standard cross-attention and self-attention blocks. Two steps are specific to FST. Equation 3 evaluates the latent field at sampled points, and Equation 5 writes the mixed values back to the anchors using field queries. We will write the two standard blocks more compactly in the final version.

For the Darcy Flow table, it's not clear to me why reported error differ significantly from those reported by the original paper. [...]

The difference comes from the dataset and the training protocol. Transolver's paper uses the original FNO Darcy benchmark on an 85 × 85 grid with 1,000 training samples. Transolver's paper quotes FNO's number from the FNO paper without retraining FNO, and trains Transolver with an extra gradient loss term. Our Table 7 uses the NeuralOperator Darcy dataset on a 128 × 128 grid with 2,000 training samples. We retrain every model under one protocol: roughly 3M parameters, a tuned learning rate, and the same loss, batch size and stopping rule. FNO's error is higher on the NeuralOperator dataset than on the original benchmark, 0.0326 vs. 0.0108, so the absolute numbers of the two tables differ. Under our shared protocol, FNO is slightly better than Transolver: 0.0326 ± 0.0012 vs. 0.0353 ± 0.0014 over three seeds.

How do we explain the number of supervision points surpassing the total number of points in Table 1?

We think the question refers to the 2,500 supervision points and the 1,424 input points in Section 4.1. The two numbers count different sets of points. The 1,424 inputs consist of 1,024 initial values and 200 values on each boundary. Each training step samples 2,500 supervision points from the 201 × 1024 = 205,824-point output grid. Section 4.1 now states both counts.

Is there any results on more difficult PDEs like Navier-stokes?

Yes. We have ran the 64 × 64 FNO Navier-Stokes benchmark at viscosity 1e-5, predicting 10 rollout snapshots from 10 inputs across 1,000 training and 200 test trajectories. Each model has roughly 3M parameters and trains for 500 epochs on one seed using canonicalization (cf. Kaba et al., 2023). We shift, rotate and mirror each input by exact flow symmetries to match a fixed reference pattern, then invert that transform on the prediction. Test rollout relative L2 errors: FST 0.0678, FNO 0.0674, Perceiver IO 0.1354, Transolver 0.0493, UPT 0.0951, DeepONet 0.2209.

Reviewer_ADcGOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents the Function-Space Transformer (FST) as a novel representational method utilising a continuous latent field defined by input-adaptive anchors. The proposed method facilitates the learning of where to store latent features instead of inheriting placements from the observation grid with recursive refinement through function-space interactions. Empirical validation is presented for PDE tasks and image classification and the FST performance is evaluated and compared with relevant baselines, FNO, Perceiver IO and ViT.

Critical strengths

The explanation of this novel methodology was very clearly presented both in text and visually through Figures 1 and 2. The core idea is well-motivated, and the proposed method has the potential to become an interesting method in the toolkit of ML practitioners.

Critical weaknesses

The main text is lacking a discussion of the tradeoffs - given that the Appendix shows that the proposed method is not significantly faster than baselines (Table 18) and that it does not beat state-of-the-art performance consistently, a discussion on limitations would be useful for ML practitioners to determine the utility of adopting the proposed method over baselines. Further rigorous demonstration of memory/complexity benefits would strengthen the claims.

The empirical results presented could be strengthened by repeating the experiments across multiple seeds and reporting standard deviation instead of a single training run.

Questions for authors

What factors contribute to FST performing worse than FNO in the single-viscosity results (Table 3) compared to the all-viscosity results (Table 2)?

3 comments

Thank you for the careful review and the helpful suggestions. We respond to each point below.

Weaknesses

The main text is lacking a discussion of the tradeoffs [...] a discussion on limitations would be useful for ML practitioners

We agree, and we have added a limitations paragraph at the end of Section 5. The paragraph makes three practical points. First, FST's memory and computation grow with the number of input points, so dense inputs cost more than fixed-grid operators. Second, FST can trail models with built-in spatial priors when training samples are scarce, as FNO shows on single-viscosity Burgers. Third, current training uses evenly spaced inputs, so irregular inputs require interpolation until we extend training to varied layouts.

We also clarified Table 18. Table 18 previously reported wall-clock hours, whereas FST used one GPU and FNO and Perceiver IO used three GPUs each. In GPU-hours, FST took 30.5, FNO 98.7 and Perceiver IO 55.8. Table 18 now reports GPU-hours.

Further rigorous demonstration of memory/complexity benefits would strengthen the claims.

We have added a cost study in Appendix E. The study reports FLOPs, inference time and memory for every Burgers and Darcy model, and shows how FST's cost grows with the number of anchors, evaluation points, inputs and queries.

FST saves memory because we can train FST on sampled output points. On Burgers we supervise 2,500 points per sample, while FNO must compute the whole 201 × 1024 grid. So FST needs about a fifth of FNO's training memory and about a quarter of FNO's GPU-hours. FST's cost also scales well. FST applies self-attention to a fixed number of evaluation points, so FST's cost grows only linearly with the number of inputs and queries (Figure 13). On the full Burgers grid, FST is about 14 times faster than Transolver at batch size 1. For decoding, spatial localization also lets each query read fewer nearby anchors, such as 16 neighbors on Burgers, at nearly the same error (Section 4.4).

The empirical results presented could be strengthened by repeating the experiments across multiple seeds

We have rerun every experiment in Tables 3-7 with three seeds, or five for Table 5, and the tables now report the mean and standard deviation. Most conclusions hold, and three results changed. On Darcy, FST now outperforms FNO by 17%, 0.0270 ± 0.0045 vs. 0.0326 ± 0.0012. The run in the submission was the worst of the three seeds. In Table 5, the function-space update still outperforms anchor self-attention, but by 11% instead of 21.9%. In Table 4, adaptive anchors help mainly at 16 × 16 anchors. With 32 × 32 anchors, a uniform layout is about as accurate as adaptive anchors. Section 4.2 now states these conditions.

Retraining the two largest experiments, Tables 2 and 8, was too expensive. For these two tables we computed 95% paired bootstrap intervals over the test samples. FST's advantage over FNO at low viscosities and FST's 1.73-point lead over ViT on ImageNet, with interval 1.39 to 2.06, both remain significant in Appendices B.5 and D.3.

Question

What factors contribute to FST performing worse than FNO in the single-viscosity results (Table 3) compared to the all-viscosity results (Table 2)?

Training-set size explains most of the gap. The single-viscosity dataset has 2,000 trajectories, while the all-viscosity dataset has 24,000. FNO builds translation equivariance into its Fourier layers. Translation equivariance is a strong prior for the periodic Burgers equation and helps most when data are scarce. FST must learn where to place the anchors and how the anchors interact, so FST needs more data, just as ViTs need more data than CNNs. The viscosity ν = 0.01 appears in both settings and shows the effect of data size directly. Moving from the small dataset to the large dataset more than halves FST's error (0.046 to 0.021) but reduces FNO's error by only about a seventh (0.029 to 0.025).

I thank the authors for the comprehensive rebuttal and updated paper. The revision addresses the main issues I raised.

The new limitations paragraph in Section 5 states the tradeoffs clearly and improves transparency. Clarifying Table 18 and adding Appendix E also gives a fairer picture of compute and memory. Based on Table 27, it seems that FST is indeed less efficient than FNO for full-grid inference. I am requesting a clarification on the text in Appendix E stating that for Burgers, "FST beats FNO" referencing Figure 14, but the top right plot in Figure 14 shows FNO beating FST throughout the run.

Rerunning Tables 3-7 across multiple seeds and adding bootstrap intervals for Tables 2 and 8 resolves my concerns about robustness across seeds and statistical significance. The answer provided to my question on the single-viscosity results makes sense.

I would also be curious to see more details on the Navier-Stokes experiment you mentioned in another comment to reviewer yqDD. Would this be added to the camera-ready version?

I maintain my recommendation for acceptance with a score of 3.

Thank you for catching that and maintaining your recommendation.

You are correct that FNO stays ahead of FST throughout the top-right plot of Figure 14 (training PFLOPs). Our sentence in Appendix E only referred to the top-left plot (GPU-hours). FST uses the GPU more efficiently there and reaches lower error before FNO's longer training overtakes it on single-viscosity Burgers. The top-right plot tracks training FLOPs. FNO stays ahead there because FST takes 1.5× FNO's FLOPs per step. We will revise that passage in Appendix E in the camera-ready version to make it clearer.

We will add the full Navier-Stokes experiment to the appendix in the camera-ready version with more seeds (one seed so far). For the current details, we use the 64 × 64 FNO Navier-Stokes vorticity benchmark at viscosity 1e-5 with 1,000 training and 200 test trajectories. Each model predicts 10 future time steps from 10 input time steps. FST keeps the same architecture as on Darcy but reads 10 input values per point instead of 1. Every model has roughly 3M parameters and trains for 500 epochs with batch size 2. Training uses AdamW with peak learning rate 0.001 under a one-cycle schedule and one-step relative L2 loss. All models also use canonicalization (cf. Kaba et al., 2023) to help respect the equation's symmetries. Before each forward pass, we align the input to a fixed reference pattern by shifting, rotating and mirroring it. We then invert that transform on the prediction. At test time we evaluate 10-step autoregressive rollout in FP32.

Reference: Kaba et al. (2023), "Equivariance with Learned Canonicalization Functions," ICML 2023.

Comments on the paper

1 comment

We thank the reviewers for their time and their detailed feedback. We have uploaded a revised PDF with changes highlighted in blue. The main changes are:

  1. We added a cost study in Appendix E. The study reports FLOPs, inference time and memory for every Burgers and Darcy model, shows how FST's cost scales, and compares accuracy at equal training cost (Reviewers 7QQg and ADcG).

  2. We reran the experiments of Tables 3-7 over three to five seeds and now report mean and standard deviation. We revised the text for each result (Reviewers ADcG and 7QQg).

  3. We added an ablation to Table 5 that changes only the field evaluation and keeps token count, parameters and FLOPs nearly the same (Reviewer 7QQg).

  4. We tested trained FST on coarser and irregularly placed inputs, in Table 20 (Reviewer 7QQg).

  5. We added a limitations paragraph to Section 5 (Reviewers ADcG and yqDD).

  6. We now discuss Functional Attention in Section 2 and state the point counts of the Burgers setup in Section 4.1 (Reviewer yqDD).

  7. We added a new baseline, the Universal Physics Transformer, on Burgers and Darcy in Tables 3 and 7 (Reviewer 7QQg).

We reply to each reviewer separately below.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.