Changing both difficulty parameters and resolution

[svdcvt]

Hello team!

I am currently running some experiments for Burgers equation and Advection-Diffusion using APEBench, but I have some confusion.

Interpretation of values

For example in Burgers, I want to change it's difficulty. So, working in "difficulty" mode (diff_burgers), given defaults N=160, L=1, dt=1.0, t=50, I need to change linear component diffusion_gamma (default 1.5) and nonlinear component convection_delta (default -1.5). Compared to the motivational example in the paper for advection, it is not straightforward to understand what and how to change these values, because for advection there is only the linear component gamma (0.5 relatively easy <---> 10.5 hard). In Advection-diffusion there are two gammas (default -4 and 4). As a person with not sufficient (hopefully, yet) intuition for physics equation, could you give some recommendation for changing these values? Should I change only one of them? Should I change both of them? Like, by default for diff_burgers it is gamma=(0,0,1.5,0), delta=(0, -1.5, 0). Should these be always as X, -X for Burgers? How this X=1.5 connected to number of points N?

Changing resolution and then difficulty

I want to increase spatial resolution (for example, from 160 to 4000 in 1D). When I change number of points, dx is changed, and then the alphas are changed inside the scenario to have chosen gammas -- the trajectory becomes "slower". Then I change gammas, so that I have the same alphas. I guess, I should first work with normalised scenarios instead? So to find the "base" gammas? And then change these. I can see from the formula that if I increase N by A=25, then I should increase these by A (37.5) and A^2 (-937.5) to have the same speed, but this seems too high. Maybe I miscalculated? And if these have increased, what will be the "interval" to get harder and easier trajectories (XX relatively easy <---> YY hard)?

Overall, what I can't figure out easily, how to scale gammas and deltas (or betas) after scaling resolution. And how these parameters' inter-ratio should be managed. On top of that, when I try-and-error some values, I get instabilities. And I also have to adjust initial conditions interval because I get instabilities too.

Do you see what am I missing? Is there a way to get "recommended" interval based on CFL condition and N?

Thanks in advance,
Sofi

[Ceyron]

Hi Sofi,

Thanks for the detailed questions! Let's break down the difficulty parameters ($\gamma$, $\delta$) and resolution scaling in APEBench.

Understanding the Interfaces (Difficulty vs. Normalized)

A key point is the difference between APEBench's parameter interfaces, especially how they handle resolution changes:

1. Difficulty Interface ($\gamma$, $\delta$): You're currently using this (e.g., diff_burgers). Its main goal, as outlined in the paper, is to keep the emulator training difficulty roughly consistent even when you change the resolution (N) or dimension (D). The difficulty parameter $\gamma_s$ is related to the normalized physical parameter $\alpha_s$ and the resolution N by $\gamma_s = \alpha_s N^s 2^{s-1} D$.

   • Why trajectories get "slower" at higher N: To keep $\gamma_s$ constant when you increase N significantly (like 160 to 4000), the underlying physical coefficient $\alpha_s$ must decrease dramatically. This results in physically slower dynamics, even though the challenge for the emulator (relative to the smaller grid spacing) is intended to be similar (which is because their performance is coupled to the receptive field which spans a smaller physical area once resolution is increased). This interface is useful if you want emulator training performance to be comparable across different resolutions.

2. Normalized Interface ($\alpha$, $\beta$): This interface works with coefficients ($\alpha_s = a_s \Delta t / L^s$, $\beta_1 = b_k \Delta t / L$) that define the normalized physical dynamics. If you use this interface and keep $\alpha$ (and $\beta$) constant, the physical behavior of the PDE simulation should remain consistent when you change N.

3. Physical Interface: For setting direct physical parameters (like velocity, viscosity), though interpreting difficulty changes can be less intuitive here since the coefficients might greatly vary in order of magnitude.

Recommendation for Changing Resolution: As you suspected, if your goal is to increase resolution (e.g., 160 to 4000) while maintaining the same physical behavior (not the same training difficulty), you should work with the Normalized interface (norm_burgers, norm_advection_diffusion, etc.). Find the $\alpha$ and $\beta$ values corresponding to your base case at N=160, and then use those same $\alpha, \beta$ values when setting up the scenario at N=4000.

PDE Components

Gamma values (γ) control the linear components of your PDE, with each gamma corresponding to a specific derivative term:

• γ₀: Drag (0th derivative)
• γ₁: Advection (1st derivative)
• γ₂: Diffusion (2nd derivative)
• γ₃: Dispersion (3rd derivative)
• γ₄: Hyper-diffusion (4th derivative)
• ...and so on

Delta values (δ) control nonlinear components:

• δ_0: Quadratic nonlinearity (as in Fisher-KPP)
• δ₁: Convection nonlinearity (as in Burgers)
• δ₂: Gradient-norm nonlinearity (as in combustion-format KS equation)

Tuning Difficulty ($\gamma$, $\delta$)

When working within the Difficulty interface at a fixed resolution, here's how to think about tuning:

• General Idea: Higher absolute values $|\gamma_i|$ or $|\delta_k|$ generally make the problem "more difficult" for typical local/convolutional emulators to predict accurately.
• Gamma Constraints (Linear/Standalone):
  • Odd derivatives ($\gamma_1$ for advection, $\gamma_3$ for dispersion): Can be any real number, $\gamma_i \in (-\infty, \infty)$. The sign determines the direction (e.g., of advection).
  • Even derivatives ($\gamma_0$ for drag, $\gamma_2$ for diffusion, $\gamma_4$ for hyper-diffusion): Usually constrained to signs that produce physically meaningful damping/diffusion when considered alone: $\gamma_0 \le 0$, $\gamma_2 \ge 0$, $\gamma_4 \le 0$, $\gamma_6 \ge 0$, etc.
• Gamma Constraints (Combined/Nonlinear):
  • These constraints can change when terms are combined or nonlinearities are present. For example, the Kuramoto–Sivashinsky (KS) equation uses $\gamma_2 &lt; 0$ (destabilizing "negative diffusion") balanced by $\gamma_4 &lt; 0$ (stabilizing hyper-diffusion) and nonlinearity. See the code example.
• Delta Constraints ($\delta_1$, $\delta_2$): Can generally be any real number, $\delta_k \in (-\infty, \infty)$.
• Stability with Nonlinearity ($\delta \neq 0$):
  • The underlying Fourier pseudo-spectral solver requires smooth states. Nonlinear terms can generate sharp gradients or shocks (like in Burgers' equation), which can lead to instability.
  • Therefore, simulations with non-zero $\delta$ values must include sufficient "smoothing" from even-order gamma terms (typically $\gamma_2 &gt; 0$, maybe also $\gamma_4 &lt; 0$, etc.). You cannot simulate Burgers (convection_delta $\neq 0$) without any diffusion term ($\gamma_2=0, \gamma_4=0, ...$).
  • The exact balance needed between $\delta$ and $\gamma$ for stability is problem-dependent (depends on N, D, other terms, initial conditions). Below is an excerpt from the thesis of a student I supervised on stable parameterizations for the Burgers equation in 1D under default settings.
    My general advice: If you increase $|\delta|$, you likely need to increase the magnitude of the stabilizing even-order $|\gamma|$ terms too (likely in a superlinear way, i.e., you scale $\delta_1$ by 3x, then $\gamma_2$ might be scaled by 9x)
  • For very strong nonlinearities (high $|\delta|$), you might also need to increase the solver's internal num_substeps for stability, as the ETDRK scheme has its own stability limits.
• Specific Cases:
  • Advection-Diffusion (gamma=(-4, 0, 4, 0)): Here $\gamma_1=-4$ (advection) and $\gamma_2=4$ (diffusion). To make advection harder, increase $|\gamma_1|$ (e.g., to -10). To make diffusion harder, increase $\gamma_2$ (e.g., to 10). To make both harder, increase both.
  • Burgers (gamma=(0,0,1.5,0), delta=(0, -1.5, 0)): Here $\gamma_2=1.5$ (diffusion) and $\delta_1=-1.5$ (convection nonlinearity). These values do not need to be X and -X. Here, this was just a coincidence. If you take a look at the image above you see that you would run into trouble with X, -X strategy starting at $X \approx 6$. You could have $\gamma_2=2.0$ and $\delta_1=-1.0$, or $\gamma_2=5.0$ and $\delta_1=-3.0$, etc., provided the combination is stable. The sign of $\delta_1$ influences the direction of shock movement.

Your Calculation for Scaling Gammas

Your calculation attempt (increase these by A (37.5) and A^2 (-937.5)) seems to stem from mixing the concepts. In the Difficulty interface, you typically don't scale $\gamma$ and $\delta$ like that when changing N; the interface handles the underlying $\alpha$ scaling internally to preserve the difficulty level (which results in the slower physical dynamics). If you were trying to maintain constant physical behavior (constant $\alpha$), I would recommend switching to the Normalized interface (or Physical Interface).

Summary Recommendations:

1. Changing Resolution & Maintaining Physics: If you want the same physical dynamics at different resolutions, use the Normalized interface ($\alpha, \beta$).
2. Changing Difficulty (at fixed N): If you want to make the problem harder/easier for the emulator at a given resolution, adjust $\gamma$ and $\delta$ in the Difficulty interface. Higher absolute values generally mean harder, keeping the sign and stability constraints in mind. I would recommend creating a simple streamlit app with sliders that produces plots of trajectories to get a feeling for reasonable value ranges.
3. Stability: Remember that nonlinearities ($\delta \neq 0$) require sufficient diffusion ($\gamma_2&gt;0$, etc.) for stability. You might also need to increase num_substeps for challenging parameters.

Hope this shines some light on this part of APEBench. Do not hesitate to ask further questions 😊. I am very happy to help and I will use the questions/replies to eventually improve the documentation of APEBench.

[svdcvt]

Hello Felix,
Thanks for such detailed answer, helped a lot!

UPD: I found an answer to my question myself now! So, ignore it.

---

I have a new question.

Recommendation for Changing Resolution: As you suspected, if your goal is to increase resolution (e.g., 160 to 4000) while maintaining the same physical behavior (not the same training difficulty), you should work with the Normalized interface (norm_burgers, norm_advection_diffusion, etc.). Find the α and β values corresponding to your base case at N=160, and then use those same α,β values when setting up the scenario at N=4000.

So I am doing this exactly now and it works perfect. But, the values I get are huge (because I increase N 10k times), for example:

1. Difficulty 1D KS_cons for N=160:
   • normalized_linear_coefficients=(0.0, 0.0, -3.90625e-05, 0.0, -3.4332275390625e-09),
   • normalized_convection_scale=0.00625,
   • linear_difficulties=(0.0, 0.0, -2.0, 0.0, -18.0),
   • convection_difficulty=1.0
2. which I use to run Normalized 1D KS_cons for N=1.6M
   • normalized_linear_coefficients (0.0, 0.0, -3.9e-05, 0.0, -3.43e-09)
   • normalized_convection_scale 0.00625
   • calculated difficulty gamma [0.0, 0.0, -199680000.0, 0.0, -1.79830784e+17]
   • calculated convection delta 10000.0
3. which I use to go back to difficulty mode and try to play with the parameters. Which is hard because values are so big!

What I want to try now, is to change domain size L, to "scale them" down, while preserving physical behaviour. Does it mean, I should calculate non-normalised linear coefficients according to the formulas for different L, and use them for in normalised mode (as if domain would be unit again), and given difficulty gamma/delta would maybe work? Not sure... I am again a bit confused. I guess my case is just a bit specific, because I am trying to "mimic" situation of having high-resolution meshes (and longer working solver code). Or is there another way to have smaller coefficients for difficulty? Or it is easier just to accept it?

Thanks in advance!